初始化器
类、结构体、枚举都可以定义初始化器
类有两种初始化器：指定初始化器（designated initializer）、便捷初始化器（convenience initalizer）
- 每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
- 默认初始化器总是类的指定初始化器
- 类偏向于少量指定初始化器，一个类通常只有一个指定初始化器
class Size {
var width:Int = 0
var height:Int = 0
//init() 默认初始化化器,一旦自定义指定初始化器，就不再自动生成init()无参初始化器
init(with:Int,height:Int){
self.width = width
self.height = height
}
}
var s = Size()
初始化器的相互调用规则
- 指定初始化器必须从它的直系父类调用指定初始化器（子类的指定初始化器必须调用父类的初始化器）
- 便捷初始化器必须从相同的类里调用另一个便捷初始化器，不能调父类的便捷初始化器
- 便捷初始化器最终必须调用一个指定初始化器
class Size {
var width:Int = 0
var height:Int = 0
// 指定初始化器
init(with: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)
}
}
var s = Size()
class Person {
var age:Int
init(age:Int){
self.age = age
}
convenience init(){
self.init(age:0)
}
}
class Student :Person {
var score:Int
init(age:Int,score:Int){
//指定初始化器必须从它的直系父类调用指定初始化器
self.score = score
self.init(age:age)
}
convenience init(){
//便捷初始化器必须从相同的类里调用另一个便捷初始化器，不能调父类的便捷初始化器
self.init(score:0)
}
convenience init(score:Int){
self.init(age:0,score:score)
}
/*
指定初始化器只能调用父类的指定初始化器，不能自己同类的指定初始化器
init(){
self.score = 0
super.init(age:0)
}
/*
}
两段式初始化
Swift在编码安全方面是煞费苦心，为了保证初始化过程的安全，设定了两段式初始化，安全检查
- 第一阶段：初始化所有存储属性（在调用初始化前，设置存储属性的值）
- 第二阶段：设置新的存储属性值，个性化操作
graph TD
Student子类便捷初始化 --> Student子类指定初始化 --> Person父类指定初始化
安全检查
- 指定初始化器必须保证在调用父类初始化器之前，其所在类定义的所有存储属性都要初始化完成（自己的属性先要设置，在调用初始化方法）
- 指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值(个性化设置)
- 便捷初始化器必须先调用同类中的其他初始化器，然后再为任意属性设置新值
- 初始化器在第一阶段完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用self
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
self.init(age:age)
//指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值
self.age = 10
}
convenience init(){
self.init(score:0,score:0)
//便捷初始化器必须先调用同类中的其他初始化器，然后再为任意属性设置新值
self.age = 10
}
}
重写
- 当重写父类的指定初始化器时，必须加上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)
}
}
2. 如果子类写了一个匹配父类的便捷初始化器的初始化器（包括指定和便捷），不用加上override
- 便捷初始化器只能横向调用，我是不能用super调用到父类的便捷初始化器，不是真正意义上的重写，不用加上override
class Person {
var age:Int
init(age:Int){
self.age = age
}
convenience init(){
self.init(age:0)
}
}
class Student:Person {
var score:Int
init(age:Int,score:Int){
self.score = score
super.init(age:age)
}
init(){
// 指定初始化器只能调用父类的指定初始化器，这个不叫重载，虽然初始化名字相同
self.score = 0
super.init(age:0)
}
/*
convenience init(){
//便捷初始化器只能横向调用（自己类的只能调用自己类的），这个不叫重写
self.score = 0
self.init(age:0,score:0)
}
*/
}
自动继承
- 如果子类没有自定义指定初始化器，那么自动继承父类的指定初始化器，也会继承父类的所有便捷初始化器
class Person {
var age:Int
var name:String
init(age:Int,name:String){
self.age = age
self.name = name
}
init(age:Int){
self.age = age
self.name = ""
}
convenience init(){
self.init(age:0)
}
}
class Student:Person {
convenience init(no:Int){
self.init(age:0)
}
}
var stu1 = Student()
var stu2 = Student(age:10)
vat stu3 = Student(age:10,name:"Jack")
var stu4 = Student(no:10)
2. 如果子类提供了父类的所有指定初始化器的实现
重写父类的指定初始化器,相对应的父类便捷初始化器也会给你
class Student:Person {
override init(age:Int,name:String){
super.init(age:age,name:name)
}
override init(age:Int){
super.init(age:age,name:"")
}
}
var stu1 = Student()
var stu2 = Student(age:10)
vat stu3 = Student(age:10,name:"Jack")
重写父类的指定初始化器为便利初始化器,相对应的父类便捷初始化器也会给你
class Student:Person {
init(no:Int){
super.init(age:0)
}
override convenience init(age:Int,name:String){
self.init(no:0)
}
override convenience init(age:Int){
self.init(no:0)
}
}
var stu1 = Student()
var stu2 = Student(age:10)
var stu3 = Student(age:10,name:"Jack")
var stu4 = Student(no:10)
注意：
- 如果子类重写了父类指定初始化器的部分，那么只会有重写的指定初始化器可以调用(便捷初始化器也不会给你)
class Student:Person {
override init(age:Int){
super.init(age:age,name:"")
}
convenience init(no:Int){}
}
var stu1 = Student(age:10)
var stu2 = Student(no:10)
2. 如果自定义指定初始化器，就不再自动继承父类的指定初始化器(大哥，我要单飞啦，不用你的初始化器啦)
class Student:Person {
init(){super.init(age:0,name:"")}
}
var stu1 = Student()
required
- 用required修饰指定初始化器，表明其所有子类都必须实现该初始化器（通过继承或者重写实现）
- 如果子类重写了required初始化器时，也必须加上required，不用加override(我都必要实现初始化啦，也必然是重写，所以不用加)
class Person {
required init(){}
init(age:Int){}
}
class Student:Person {
required init(){
super.init()
}
}
属性观察器
- 父类的属性在它自己的初始化中赋值不会触发属性观察器，但在子类的初始化器中赋值会触发属性观察器
class Person {
var age:Int {
willSet {
print("willSet",newValue)
}
didSet {
print("didSet",oldValue,age)
}
}
init(){
self.age = 0
}
}
class Student:Person {
override init(){
super.init()
self.age = 1
}
}
//willSet 1
//didSet 0 1
var stu = Student()
可失败初始化器
- 类、结构体、枚举都可以使用init？定义可失败初始化器
class Person {
var name:String
init?(name:String){
if name.isEmty {
return nil
}
self.name = name
}
}
var p1 = Person(name:"")
print(p1) // nil
var p2 = Person(name:"Jack")
print(p2) // Optional(SwiftDemo.Person)
- 接触过的可失败初始化器
var name = Int("123")
public init?(_ description:String)
enum Answer : Int {
case wrong,right
}
var an = Answer(rawValue:1)
- 不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器(报错：重复定义)
- 可以用init!定义隐式解包的可失败初始化器
class Person {
var name:String
init！(name:String){
if name.isEmty {
return nil
}
self.name = name
}
}
- 可失败初始化器可以调用非可失败初始化器，非可失败初始化器调用可失败初始化器需要进行解包
class Person {
var name:String
convenience init?(name:String){
if name.isEmty {
return nil
}
self.name = name
}
init(){
self.name = ""
}
}
非可失败初始化器调用可失败初始化器
方式一
class Person {
var name:String
init?(name:String){
if name == "" {
return nil
}
self.name = name
}
convenience init() {
self.init(name: "")!
}
}
方式二
class Person {
var name:String
init!(name:String){
if name == "" {
return nil
}
self.name = name
}
convenience init() {
self.init(name: "")
}
}
没有解包的情况
报错：error: a non-failable initializer cannot delegate to failable initializer 'init(name:)' written with 'init?'
self.init(name: "")
^
- 如果初始化器调用一个可失败初始化器导致初始化器失败，那么整个初始化过程都失败，并且之后的代码都停止执行
- 可以用一个非可失败初始化器重写一个可失败初始化器，但反过来是不行的
反初始化器（deinit）
-
deinit叫做反初始化器，类似于C++的析构函数，OC中的dealloc方法
-
当类的实例对象被释放内存时，就会调用实例对象deinit方法
-
deinit不接受任何参数，不能写小括号，不能自行调用
-
父类的deinit能被子类继承
-
子类的deinit实现执行完毕后会调用父类的deinit
class Person {
deinit{
print("Person对象销毁了")
}
}
class Student :Person {
deinit {
print("Student对象销毁了")
}
}
func test(){
var stu = Student()
}
print("1") //1
test() // Student对象销毁了 -> Person对象销毁了
print("2") //2
可选链（Optinal Chaining）
- 如果可选项为nil，调用方法、下标、属性失败，结果为nil。
- 如果可选项不为nil，调用方法，下标，属性成功，结果会被包装成可选项
- 如果结果本来就是可选项，不会进行再次包装
- 多个？可以链接在一起
- 如果链中任何一个节点是nil，那么整个链就会调用失败
func getName -> String{"Jack"}
class Car {var price = 0}
class Dog {var weight = 0}
class Person {
var name:String = ""
var dog:Dog = Dog
var car:Car? = Car()
func age() -> Int{18}
func eat() {print("Person eat")}
subscript(index:Int)->Int{index}
}
var person:Person? = Person()
var age = person?.age() //Int? ,Optional(18)
var name = person?.name //String?
//如果person为nil，不会调用getName()
var person?.name = getName()
if let _ = person?.eat() {
print("调用eat成功")
}else {
print("调用eat失败")
}
var dog = person?.dog // Dog?
var height = person?.dog?.weight // Int?
var price = person?.car?.price // Int?
var scores = ["Jack":[86,82,84],"Rose":[79,94,81]]
scores["Jack"]?[0] = 100
scores["Rose"]?[2] += 10
scores["Kate"]?[0] = 88
var num1:Int? = 5
num1? = 10 // Optional(10),num1? 会判断num1 是否为nil，为nil，就不执行赋值操作
var num2:Int? = nil
num2? = 10 // nil num2为nil，就不执行赋值操作
var dict:[String:(Int,Int) ->Int] = [ "sum":(+), "difference":(-)]
var result = dict["sum"]?(10,20) // Optional(30),Int?
