Swift中初始化器：
- 指定初始化器(designated initializer)
- 便捷初始化器(convenience initializer)
初始化器定义
// 指定初始化器
init(parameters) {
statements
}
// 便捷初始化器
convenience init(parameters) {
statements
}
通常每个类的初始化器有如下特点
1.每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
2.默认初始化器总是类的指定初始化器
3.类偏向于指定初始化器，一个类通常只有一个指定的初始化器
关于指定初始化器和便利初始化器关系，有以下三个原则
1.指定初始化器必须调用它的直接直系父类指定初始化器
2.便捷初始化器必须调用本类的另一个初始化器(可以使便利或指定)
3.编辑初始化器“最终”必须调用一个指定初始化器(这里的最终是指调用链的尾端必须调用指定初始化器)
一、初始化器的调用规则
- 指定初始化器：纵向调用
- 便利初始化器：横向调用
纵向调用：指子类指定初始化器调用父类指定初始化器(指定初始化器之间不能相互调用)
横向调用：指本类内部相互调用(便利初始化器可以调用便利和指定初始化器)
第一阶段：初始化所有存储属性
1.外层调用指定、便捷初始化器
2.分配内存给实例（有了存储空间，但未初始化，空间内是垃圾数据）
3.指定初始化器确保当前类的存储属性都被初始化
4.指定初始化器调用父类的初始化器，不断向上，形成初始化器链
第二阶段：设置新的存储属性
1.从顶部初始化器向下，链中的每一个指定初始化器都有机会进一步定制实例
2.此时初始化器能够使用self(访问、修改属性，调用实例方法等等)
3.最终，链中任何便捷初始化器都有机会定制实例以及使用self
二、初始化器的调用规则
- 1.指定初始化器之间不能相互调动
一个指定初始化器意味着一条特定的业务场景线，所以相互之间不能调用
如下一个类，有两个指定初始化器init(age: Int, name: String)和init(age: Int),这两个初始化器之间是不能调用的，因为初始化后产生的业务场景并不同
class Object {
var age = 10
var name = "Rose"
init(age: Int, name: String) {
self.age = age
self.name = name
}
init(age: Int) {
self.age = age
self.name = "Jack"
}
}
2.便利初始化器可以调用指定初始化器，也可以调用便利初始器(此情况最终传递到指定初始化器)
如下初始化器的传递情况init()-->init(age: Int)-->init(age: Int, name: String),虽然前两个初始化器都是便利初始化器，但最终落脚点是指定初始化器
class Object {
var age = 10
var name = "Rose"
init(age: Int, name: String) {
self.age = age
self.name = name
}
convenience init(age: Int) {
self.init(age: 10, name: "Jack")
}
convenience init() {
self.init(age: 10)
}
}
三、初始化器继承
- 当子类不写任何初始化器的时候，默认继承父类所有初始化器
- 当子类不写任何指定初始化器的时候，默认继承父类所有初始化器
class Object {
var age = 10
var name = "Rose"
init(age: Int, name: String) {
self.age = age
self.name = name
}
convenience init(age: Int) {
self.init(age: 10, name: "Jack")
}
convenience init() {
self.init(age: 10)
}
}
class Person: Object {
var sex = true
convenience init(sex: Bool) {
self.init()
self.sex = sex
}
convenience init(sex: Bool, name: String) {
self.init(age: 20)
self.sex = sex
}
}
这里的Person实际上已经默认继承了Object的所有初始化器，这里Person拥有5个初始化器
- 当子类有自定义初始化器的时候，不会继承父类初始化器(包括指定和便利)
class Object {
var age = 10
var name = "Rose"
init(age: Int, name: String) {
self.age = age
self.name = name
}
convenience init(age: Int) {
self.init(age: 10, name: "Jack")
}
convenience init() {
self.init(age: 10)
}
}
class Person: Object {
var sex = true
init() {
super.init(age: 20, name: "sss")
}
convenience init(sex: Bool) {
self.init()
self.sex = sex
}
}
这里的Person没有继承Object的所有初始化器，Person只有本身的2个初始化器
- 当子类没有新的指定初始化器，但是重写了父类的指定初始化器的时候，此时父类的所有初始化构造器都会被继承下来
便捷初始化器不能重写，也就是子类不能够重写，严格意义上来说不能算继承
class Object {
var age = 10
var name = "Rose"
init(age: Int, name: String) {
self.age = age
self.name = name
}
convenience init(age: Int) {
self.init(age: 10, name: "Jack")
}
convenience init() {
self.init(age: 10)
}
}
class Person: Object {
var sex: Bool
override init(age: Int, name: String) {
sex = false
super.init(age: age, name: name)
}
}
这里的Person继承了Object的所有初始化器，这里Person拥有3个初始化器
三、两段式初始化
所有分段式初始化，即一个初始化函数的内部初始化过程分为两段(三个步骤)
- 初始化自己所有存储属性
- 调用父类初始化方法super.init()
- 个性化定制（为成员变量重新赋值、调用成员方法等）
init(sex: Bool, id: String) {
// 1. 初始化自己所有存储属性
self.sex = sex
self.id = id
// 调用父类初始化方法
super.init(age: 10, name: "Jack")
// 3. 个性化定制
self.age = 20
self.name = "Jack1"
self.test()
}
swift为了安全性更上一个等级，设计了这样一个两段式结构，过程体现如下
初始化属性：子类-->父类-->...-->基类
个性化定制：基类-->...-->父类-->子类
原理上来说，运用了栈的结构思想，保证了：
1.所有继承链上的成员变量能够被初始化到
2.指定初始化器形成调用链
3.个性化定制一定在类完全初始化之后
四、安全检查
- 指定初始化器必须在保证调用父类初始化器之前，必须保证本类所有存储属性都要初始化完成
- 指定初始化器必须在调用父类初始化器之后，才能为继承的属性设置新值
- 便捷初始化器必须先调用同类中国的其它指定初始化器之后，才能为任意属性设置新值
- 初始化器在1阶段完成之前不能访问self、属性即调用实例方法
- 直到阶段1结束，才能算初始化过程合法
五、重写
- 当重写父类的指定初始化器时，必须加上override（即使子类的实现是便捷初始化器）
- 如果子类写了一个匹配父类便捷初始化器的初始化器，不用加上override因为父类的便捷初始化器永远不会通过子类直接调用，因此，严格来说，子类无法重写父类的便捷初始化器
六、自动继承
- 1.如果子类没有定义任何指定初始化器，它会自动继承父类所有的指定初始化器
- 2.如果子类提供了父类所有指定初始化器的实现(要么通过方式1继承，要么重写)，那么子类自动继承所有的父类便捷初始化器
- 3.就算子类添加了更多的便捷初始化器，这些规则仍然适用
- 4.子类以便捷初始化器的形式重写父类的指定初始化器，也可以作为满足规则2的一部分
总结
- 1.初始化器必须满足分段规则
- 2.只要之类没有自定义新的 指定 初始化器（继承和重写得来的不算），子类拥有父类所有初始化器
- 3.便捷初始化方法内部不能使用super调用父类初始化器，只能使用self调用本身拥有或继承得来的
