简介
作为iOS开发，大家都知道OC的派发方式其实就是利用runtime采用了运行时机制使用obj_msgSend发送消息，
Swift也可以使用OC的运行时和消息转发机制，因为swift和OC是可以混编的，不过swfit也有其他的派发方式，今天就来讨论下swift支持的派发方式
派发方式
Swift可以通过关键字dynamic对方法进行标记，这样就会告诉编译器，此方法使用的是OC的运行时机制
总的来说，Swift通过dynamic关键字的扩展后，一共包含三种方法分派方式：Static dispatch，Table dispatch和Message dispatch，
直接派发是最快的, 不止是因为需要调用的指令集会更少, 并且编译器还能够有很大的优化空间, 例如函数内联等, 直接派发也有人称为静态调用.
函数表派发是编译型语言实现动态行为最常见的实现方式. 函数表使用了一个数组来存储类声明的每一个函数的指针. 大部分语言把这个称为 “virtual table”(虚函数表), Swift 里称为 “witness table”. 每一个类都会维护一个函数表, 里面记录着类所有的函数, 如果父类函数被 override 的话, 表里面只会保存被 override 之后的函数. 一个子类新添加的函数, 都会被插入到这个数组的最后. 运行时会根据这一个表去决定实际要被调用的函数.
消息机制是调用函数最动态的方式. 也是 Cocoa 的基石, 这样的机制催生了 KVO等功能. 这种运作方式的关键在于开发者可以在运行时改变函数的行为. 不止可以通过 swizzling来改变, 甚至可以用 isa-swizzling修改对象的继承关系, 可以在面向对象的基础上实现自定义派发
理解这些派发方式可以帮我们更好的理解和处理开发中遇到的问题
下面就来说一些跟派发方式有关系的例子1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20class Base : NSObject {
var name: String { return "this is base" }
var nickName: String { return self.name }
dynamic var age : Int { return 10 }
dynamic func say() {}
}
class Sub: Base {
}
/// 子类的extension中不能重写父类的非dynamic的属性和方法
extension Sub {
// override var name: String { return "sub" }
// override var age: Int { return 20 }
override func say() {}
}
let sub = Sub()
print(sub.age)
在这个例子中，子类的extension中不能重写name和nickName，但是可以重写age和say(),
如果类不是继承NSObject,而是纯Swift类也是一样的。
出现这个问题的原因是，NSObject的extension是使用的Message dispatch，而Initial Declaration使用的是Table dispath（查看上图 Swift Dispatch Method）。extension重载的方法添加在了Message dispatch内，想在extension重载方法，需要标明dynamic来使用Message dispatch
再看另一个例子1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25protocol Greetable {
func sayHi()
}
extension Greetable {
func sayHi() {
print("hello")
}
}
class Person : Greetable {
}
class LoundPerson: Person {
func sayHi() {
print("SubPerson")
}
}
var sub: LoundPerson = LoundPerson()
sub.sayHi() /// SubPerson
var subs: Person = LoundPerson()
subs.sayHi() /// hello
在子类LoudPerson中没有出现override关键字。可以理解为LoudPerson并没有成功注册Greetable在Witness table的方法。所以对于声明为Person实际为LoudPerson的实例，会在编译器通过Person去查找，Person没有实现协议方法，则不产生Witness table，sayHi方法是直接调用的。解决办法是在base类内实现协议方法，无需实现也要提供默认方法。或者将基类标记为final来避免继承
1 | protocol Greetable { |
下面可以看这个例子更加深入的理解一下1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42// Defined protocol。
protocol A {
func a() -> Int
}
extension A {
func a() -> Int {
return 0
}
}
// class doesn't have implement of the function。
class B: A {}
class C: B {
func a() -> Int {
return 1
}
}
// class has implement of the function。
class D: A {
func a() -> Int {
return 1
}
}
class E: D {
override func a() -> Int {
return 2
}
}
// Failure cases。
B().a() // 0
C().a() // 1
(C() as A).a() // 0 # We thought return 1。
// Success cases。
D().a() // 1
(D() as A).a() // 1
E().a() // 2
(E() as A).a() // 2
子类不能重写父类的extension中的方法1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16class Teacher {
}
extension Teacher {
func talk() {
print("talk")
}
}
/// 子类不能重写父类的extension声明的方法
class SubTeach: Teacher {
override func talk() {
print("sub talk")
}
}
上面的例子编译是不会通过的，如果把talk标记为dynamic是可以通过的