特别备注
本系列文章总结自MJ老师在腾讯课堂Swift编程从入门到精通-MJ大神精选，相关图片素材均取自课程中的课件。
多态是面向对象的三大特性之一,当时设计OOP机制的时候，能够想到多态的人，真特么太牛叉了。
那什么是多态呢，满足下面这几个条件就可以称为多态：
1、继承了某个类、实现了某个接口
2、重写父类的方法、实现接口中的方法
3、父类引用指向子类对象
一. 多态实现原理
多态就是父类指针指向子类对象
关于多态：在编译的时候并不知道要调用的是父类还是子类的方法，运行的时候才会根据实际类型调用子类的方法。
对于结构体来说，因为结构体没有继承，编译的时候就能知道调用哪个方法。
但是对于类，只有在运行的时候才能知道实际调用哪个方法。
- 多态实现原理：
OC：通过Runtime将一些方法放到方法列表里面 - C++：虚表（虚函数表）
- Swift中的多态：和虚表很像
先看下面这段程序的运行，咋们开始分析swift多态的实现原理。
class Animal {
func speak() {
print("Animal speak")
}
func eat() {
print("Animal eat")
}
func sleep() {
print("Animal sleep")
}
}
class Dog : Animal {
override func speak() {
print("Dog speak")
}
override func eat() {
print("Dog eat")
}
func run() {
print("Dog run")
}
}
var anim = Animal() //父类指针
anim = Dog() //指向子类对象
//这时候，编译器提示，anim是Animal类型的，但是实际是Dog类型的
anim.speak()
anim.eat()
anim.sleep()
Run->
Dog speak Dog eat Animal sleep
先从结构体开始看方法的调用
struct Animal {
func speak() {
print("Animal speak")
}
func eat() {
print("Animal eat")
}
func sleep() {
print("Animal sleep")
}
}
var anim = Animal()
anim.speak()
anim.eat()
anim.sleep()
首先看看调用结构体方法的汇编:
struct结构体，不存在继承，方法在编译的时候就和类型绑定了，知道函数编译后的地址，直接使用call调用。
我们把struct改成class,再来看看他的的汇编:
可以看到,方法地址不是固定的,而是通过一定计算得来的.因为class支持继承,所以它的方法地址一定不是写死的,而是通过计算得来的.所以在项目中如果我们只是单纯的调用方法,那我们用结构体就可以了,从汇编代码可以看出,结构体的汇编代码更少,流程更简单,效率更快.
下面我们就来研究 Swift 中,多态的实现原理.使用一开始就多态示例运行的代码，来看汇编运行步骤
运行到callq *0x50(%rcx) 可以看到rcx读取的值为0x000000010000c6b8 type metadata for TestSwift.Dog
为Dog对象的类型信息metadata
如下图，通过窥探汇编得到的：
上图就是子类在调用方法的时候是如何调用的流程,需要注意的是类型信息存储在全局区
多态原理
我们都知道Dog对象的前8个字节是指向类型相关信息(metadata)，如上图，类型相关的那块区域里面，前面一块区域存放Dog的类型信息相关，后面一块区域存放方法的地址，比如Dog重写了speak和eat，所以这两个方法在最前面，没有重写sleep所以再后面是Animal.sleep，最后是Dog.run。
当调用anim.speak()，首先先取出Dog对象的前8个字节，根据这8个字节指针找到指针指向的内存，找到内存地址之后加上一个固定偏移量，就会获得Dog.speak方法的内存地址，找到方法之后调用。
同理，Dog eat也是先取出前8字节，找到这8字节的内存地址，然后再加上一个固定偏移量，找到Dog.eat方法，找到方法之后调用。
如果Dog没有重写Animal的方法，那么类型信息那块区域存储的方法就是，如下图：
如果是两个dog对象，他们的类型信息肯定也是一样的，如下图：
那么Dog的类型信息会放在代码段、数据段、堆、栈中的哪一段？
我们可以猜测一下，因为类型信息要一直在内存中，首先排除栈，代码段一般放编译之后的代码也排除，堆空间一般放alloc，malloc等动态分配的东西，也排除，所以Dog的类型信息只能存放数据段。
总结：程序在编译的时候就将函数地址放到了类型信息那块内存区域了，当程序运行的时候再到这块内存区域找函数地址，找到之后就调用。
二. 初始化器
初始化器
枚举：枚举可以使⽤rawValue来给枚举赋值，没有自动生成的初始化器。
结构体：所有的结构体都有编译器⾃动⽣成的初始化器(也许不⽌⼀个)，⽤于初始化所有成员，但是如果你⾃定义了初始化器，编译器就不会帮你了。
类：编译器没有为类⾃动⽣成可以传⼊成员值的初始化器(想让我们⾃⼰写)，但是如果属性都有默认值，也会帮我们创建⼀个⽆参初始化器。
枚举、结构体、类都可以自定义初始化器。
类有2种初始化器：指定初始化器（designated initializer）、便捷初始化器（convenience initializer）
// 指定初始化器
init(parameters) {
statements
}
// 便捷初始化器
convenience init(parameters) {
statements
}
初始化器的唯一原则就是:保证所有成员都有值.在 swift 中,初始化器可以分为两种:1: 指定初始化器 , 2:便捷初始化器
每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
默认初始化器总是类的指定初始化器
类偏向于少量指定初始化器，一个类通常只有一个指定初始化器
初始化器的相互调用规则：
1. 指定初始化器必须从它的直系父类调用指定初始化器
2. 便捷初始化器必须从相同的类里调用另一个初始化器，最终必须调用一个指定初始化器
1:指定初始化器
指定初始化器就是之前我们使用的初始化器,没有自动生成的初始化器
class Size {
var width: Int = 0
var height: Int = 0
}
var s4 = Size()
从汇编我们可以看到，调用了Size的init()方法。
自定义初始化器
一旦我们自定义了初始化器,编译器就不会为我们再生成默认初始化器了.
指定初始化器就是类的主要初始化器,可以理解为主线.一个类至少有一个指定初始化器,并且 swift 官方建议不要过多的指定初始化器,一个类通常只有一个指定初始化器.
- 定义便携初始化器
class Size {
var width: Int = 0
var height: Int = 0
convenience init(width: Int, height: Int) {
self.init()
self.width = width
self.height = height
}
}
- 便捷初始化器必须从相同的类里调用另一个初始化器，最终必须调用一个指定初始化器
class Size {
var width: Int
var height: Int
// 指定初始化器（主要初始化器）
init(width: Int, height: Int) {
self.width = width
self.height = height
}
convenience init(width: Int) {
self.init(width: width, height: 0)
}
convenience init(height: Int) {
self.init(width: 0, height: height)
}
convenience init() {
self.init(width: 0, height: 0)
}
}
如果有继承关系的类,子类的指定初始化器必须调用直系父类的指定初始化器
那便捷初始化器可不可以调用便捷初始化器呢?
从上图可以看到,便捷初始化器是可以调用便捷初始化器的,但是必须遵从一条规则:便捷初始化器最终必须要调用指定初始化器
总结:
1. 如果是指定初始化器,必须调用直系父类的指定初始化器;
2. 如果是便捷初始化器,必须调用自己的指定初始化器;
这一套规则保证了使用任意初始化器，都可以完整地初始化实例。
2. 两段式初始化、安全检查
class BasePerson {
var IDnum: Int
init(IDnum: Int) {
//这里打印：print(self.IDnum)和方法调用self.test()，都会报错：Variable 'self.IDnum' used before being initialized
self.IDnum = IDnum //8.父类的指定初始化器初始化自己的属性
//9.至此第一阶段结束，才可以使用self
print(self.IDnum) //这里打印不会报错
self.test() //方法调用也不会报错
}
convenience init() {
self.init(IDnum: 1234567890)
}
func test() -> Void {
print("测试")
}
}
class Person : BasePerson {
var age: Int
var name: String
init(age: Int, name: String) { //5.来到父类的指定初始化器
self.age = age
self.name = name //6.父类也是先初始化自己的属性
super.init(IDnum: 0) //7.再调用父类的指定初始化器
self.IDnum = 3412211992 //10.父类的初始化器调用完，接着进一步定制实例
}
convenience init() {
self.init(age: 0, name: "")
}
convenience init(age: Int) {
self.init(age: age, name: "")
}
convenience init(name: String) {
self.init(age: 0, name: name)
}
}
class Student : Person {
var score: Int
init(age: Int, score:Int) {
self.score = score; //3.指定初始化器确保当前类定义的存储属性都初始化
super.init(age: age, name: "") //4.指定初始化器调用父类的初始化器，不断向上调用，形成初始化器链
self.age = 10 //11.父类的初始化器调用完，接着进一步定制实例
}
convenience init() {
self.init(age: 0, score:0) //2.便捷初始化器调用指定初始化器
//12.至此第二阶段结束，所有初始化完成
}
}
var stu = Student() //1.外层调用便捷初始化器
- 安全检查
- 指定初始化器必须保证其所在类定义的所有存储属性都要初始化完成，再调用父类初始化器
- 指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值
- 便捷初始化器必须先调用同类中的其它初始化器，然后再为任意属性设置新值
- 初始化器在第1阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用self
- 直到第1阶段结束，实例才算完全合法
初始化器的重写
- 当子类重写父类的指定初始化器时,必须加上
override关键字.子类可以把父类的指定初始化器重写为指定初始化器和便捷初始化器.- 重写为指定初始化器
class Person {
var age: Int
init(age: Int) {
self.age = age
}
}
class Student : Person {
var score : Int
init(age: Int, score: Int) {
self.score = score
super.init(age: age)
}
override init(age: Int) {
self.score = 0
super.init(age: age)
}
}
- 重写为便捷初始化器
class Student : Person {
var score : Int
init(age: Int, score: Int) {
self.score = score
super.init(age: age)
}
override convenience init(age: Int) {
self.init(age: age,score: 0)
}
}
- 如果子类重写了一个和父类便捷初始化器一模一样的初始化器,不用加
override,严格来讲,这并不是重写.
因为便捷初始化器是横向调用的,它只能在类本身调用,子类是不能调用父类的便捷初始化器的.而重写可以通过super调用父类的方法,但是却不能通过super调用父类的便捷初始化器,这就冲突了.
初始化器的继承
- 如果子类没有自定义任何指定初始化器,它将继承父类所有指定初始化器
class Person {
var age: Int
var name: String
init(age: Int, name: String) {
self.age = age
self.name = name
}
init() {
self.age = 0
self.name = ""
}
}
class Student : Person {
}
- 如果子类提供了父类所有指定初始化器的实现(
两种方式: 1: 通过第一条继承 2: 通过重写),子类会自动继承所有父类的便捷初始化器
class Person {
var age: Int
var name: String
init(age: Int, name: String) {
self.age = age
self.name = name
}
init() {
self.age = 0
self.name = ""
}
convenience init(age: Int) {
self.init(age: age, name: "")
}
convenience init(name: String) {
self.init(age: 0, name: name)
}
}
特别备注
本系列文章总结自MJ老师在腾讯课堂Swift编程从入门到精通-MJ大神精选，相关图片素材均取自课程中的课件。