Swift -- 8.2 类的构造与析构

类中的存储属性必须要在构造过程中设置初始值，加上继承的的属性，类的构造过程比较复杂

析构器 deinit函数

在实例销毁之前被系统调用，实例不能自己调用

值类型的构造器可以直接调用一个其他的构造器，但是类的构造器不可以，必须要用convenience来变成便利构造器，然后才能调用其他的构造器

如果有父类，需要使用super来调用父类的构造器

class Apple1 {
    
    var name:String!
    var weight:Double
    
    init(name:String, weight:Double){
        self.name = name
        self.weight = weight
    }
    
    init(nn name:String, weight:Double){//构造器重载
        self.name = name
        self.weight = weight
    }
    
    convenience init(n name:String, w weight:Double){//变成便利构造器来调用其他构造器
        self.init(name:name, weight:weight)
        self.name  = name
    }
    
}

class Pear: Fruit {
    init(weight:Double){
        super.init()//调用父类的构造器
        self.weight = weight
    }
}

　　

两段式构造

 

swift类的构造需要两个阶段完成

第一阶段：先为存储属性分配内容，使用本类的构造器初始化由本类定义的存储属性，然后沿着构造器链向上，逐个调用各父类构造器初始化对应父类定义的存储属性

第二阶段：从最顶层开始，沿着顶部构造器链向下，每个构造器都可以再次修改存储属性

 

为了保证两段式构造顺利完成，swift提供了四种安全检查

1：指定构造器必须先初始化当前类中定义的实例存储属性，然后才能向上调用父类构造器

2：指定构造器必须先向上调用父类构造器，然后才能对继承得到的属性赋值

3：便利构造器必须先调用同一个类的其他构造器，然后才能对属性赋值

4：构造器在第一阶段完成之前，不能调用实例方法，不能读取实例属性

 

swift类的构造器规则比较繁琐，因此处理起来比较容易出错，但如果程序显式地为所有实例存储属性指定初始值，定义构造器时就会简单得多，而且可以直接利用系统默认的构造器（hiahiahia   因为这样做的话，只需要把所有的构造器都写在第一行就永远不会出错了hiahiahia）

class A{
    var name : String
    init(name:String){
        self.name = name
    }
}
class B: A {
    var age:Int
    init(age:Int){
        self.age = age
        super.init(name: "")
        self.run()

    }
    func run(){
        print("run");
    }
}

var bb = B(age: 22)

　　

构造器的继承和重写

 

构造器的继承规则

1 如果子类没有提供任何构造器，那么它会继承父类的所有指定构造器和便利构造器

2 如果子类实现了父类的所有指定构造器（比如说使用方法1或是重写来实现），那么它将继承父类的所有便利构造器

      反而言之，如果子类自己写了构造器，并且没有重写父类的指定构造器，那么它就不能继承父类的构造器

class F
{
    var name : String
    var weight : Double
    init(name:String, weight:Double){
        self.name = name
        self.weight = weight
    }
    init(n name:String){
        self.name = name
        self.weight = 0.0
    }
     convenience init(){
        self.init(n:"")
        self.weight = 1.0
    }
}

class App: F {
    var color : String
    override init(name:String, weight:Double){
        self.color = ""
        super.init(name: name, weight: weight)
    }
    override init(n name:String){
        self.color = ""
        super.init(n: name)
    }
    init(name:String, weight:Double, color:String){
        self.color = color
        super.init(name: name, weight: weight)
    }
    convenience init(name:String, color:String){
        self.init(name:name, weight:0.0, color:color)
    }
}

class Fuji: App {
    var vitanim : Double = 0.21
}
var ff = App()
ff.weight
var tt = Fuji(name: "", color: "")

//子类的构造器不能与父类的构造器的形参列表相同，如果相同需要添加override关键字。但是如果父类的构造器是便利构造器就没有事
class F2 {
    var name : String
    init(){
        self.name = ""
    }
    
    convenience init(name:String){
        self.init()
    }
}

class F3: F2 {
    var color : String
    init(name:String){//这个构造器父类中也有，不过父类中是便利构造器，所以子类中依然可以使用
        self.color = ""
        super.init()
    }
}

　　

类与可能失败的构造器

 

可能失败的构造器必须满足的两个条件

1 该类中所有实例存储属性都已被赋值

2 所有的构造器调用都已经被执行（return nil 不能位于self.init 或 super.init代码之前）

 

如果子类调用父类的可能失败的构造器，那么如果父类的构造器return nil，那么子类构造器中之后的代码都不会被执行

在重写可能失败的构造器的时候，可以重写成可能失败的构造器，也可以重写成普通构造器

class User {
    var name : String
    init?(name:String){
        self.name = ""
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

class Student: User {
    var grade : Int!
    init!(name:String, grade:Int){
        super.init(name: name)//如果这个构造器失败，那么之后的代码都不会被执行
        if grade < 1{
            return nil
        }
        self.grade = grade
    }
}
//所以在类中，可能失败的构造器可以调用普通的构造器，普通的构造器不能调用可能失败的构造器

class C1 {
    var name : String
    init!(name:String){
        self.name = ""
        if name.isEmpty{
            return nil
        }
        self.name = name
    }
}

class C2: C1 {
    var color : String
    init?(name:String, color:String){
        self.color = ""
        super.init(name: "")
        
    }
    init(color:String){
        self.color = color
        super.init(name: "")//虽然这里没有报错，但是使用实例的时候会出错的
    }
}
let ccccc = C2(name: "", color: "")

　　

子类必须包含的构造器

使用required来标记构造器，表示子类构造器必须包含这个构造器

可以通过重写和继承来得到

class Fruit5 {
    var name:String
    required init(name:String){
        self.name = name
    }
    
    
}

class Apple5: Fruit5 {
    var weight : Double
    init(weight:Double){
        self.weight = weight
        super.init(name: "")
    }

    required init(name: String) {//不写这个构造器会报错
        self.weight = 0
        super.init(name: name)
    }
}

　　

析构器

deinit

在实例被销毁之前调用

析构器是系统自动调用的，实例不可以自己调用

子类的析构器执行结束时将自动调用父类的析构器

class T1 {
    var name : String = "nn"
    deinit{
        print("the T1 is deinit")
    }
}

class T2: T1 {
    deinit{
        print("the T2 is deinit")
    }
}
var ap:T2? = T2()
ap!.name
ap = nil
//the T2 is deinit
//the T1 is deinit