Swift类和子类的初始化总结

Swift中类和子类的初始化有一定的规则，不是很容易理解，现在简单梳理一下：

两段式初始化（ two-phase initialization）

首先要记住一点，Swift中类的初始化的时候，所有存储属性（Stored Property）要么有初始值，要么在初始化的时候通过init赋值（optional 除外），否则编译不通过，比如：

class Car {
    let wheel: Int
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }  // Return from initializer without initializing all stored properties
}

只有所有存储属性都初始化了，才可以编译通过：

class Car {
    let wheel: Int = 4
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }
}  //  编译通过

这个规则同样适用于子类，如果子类继承父类后，引入了新的存储属性，那么新的存储属性也有相同的规则，比如下面的子类因为没有初始化新的存储属性而编译不过：

class FordCar:Car {
    let year: Int
    init(windows: Int) {
        super.init(windows: windows)  // Property 'self.year' not initialized at super.init call
    }
}

而且我们发现，子类的存储属性初始化必须在调用父类初始化之前，比如下面还是编译不过：

class FordCar: Car {
    let year: Int
    init(windows: Int, year: Int) {
        super.init(windows: windows)  // Property 'self.year' not initialized at super.init call
        self.year = year  // Immutable value 'self.year' may only be initialized once
    }
}

那么子类的初始化遵循什么规则呢？Swift官方的规定是两段式初始化（ two-phase initialization）：

第一阶段：自底向上（从子类到父类），初始化所有的储存属性
第二阶段：第一阶段结束后，才能使用属性和方法

简单的说，第一阶段规定了子类新属性的初始化要放到super.init之前，比如：

class Car {
    let wheel: Int = 4
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }
}

class FordCar: Car {
    let year: Int
    init(windows: Int, year: Int) {
        self.year = year
        super.init(windows: windows)
    }
}

class SuperFordCar: FordCar {
    var power: Double
    init(windows: Int, year: Int, power: Double) {
        self.power = power
        super.init(windows: windows, year: year)
    }
}

对于第二阶段，简单的理解就是使用属性或者方法要在super.init之后，否则使用属性或者方法的时候，可能父类或者子类的属性都还没有初始化，接上面的例子，比如下面的用法编译不过：

class SuperFordCar: FordCar {
    var power: Double
    init(windows: Int, year: Int, power: Double) {
        self.power = power
        allPower()  // 'self' used in method call 'allPower' before 'super.init' call
        super.init(windows: windows, year: year)
    }
    
    func allPower() {
        power = power * Double(wheel)
        print(power)
    }
}

allPower()方法必须要在父类初始化之后才能使用

理解了两段式初始化之后，下面我们再理解一下必须初始化（Required initializers）和 便利初始化（convenience initializers）

必须初始化（Required initializers）

假设父类有多个初始化方法：

class FordCar: Car {
    let year: Int
    init(windows: Int, year: Int) {
        self.year = year
        super.init(windows: windows)
    }

    init(standWindows: Int = 4, currentYear: Int = 2020) {
        year = currentYear
        super.init(windows: standWindows)
    }
}

这时，子类继承的时候可以选择任意一个父类的初始化方法作为自己初始化时候需要调用的方法，但这里选择的空间过大，Swift因此引入了required关键字，用来修饰父类的初始化方法，使得子类初始化的时候必须重载（override）这个必须初始化 (override关键字可以省去)：

class Car {
    let wheel: Int = 4
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }
    required init(standardWindows: Int = 4) {
        self.windows = standardWindows
    }
}

class FordCar: Car {
    let year: Int
    init(windows: Int, year: Int) {
        self.year = year
        super.init(windows: windows)
    }
    required init(standardWindows: Int = 4) {
        self.year = 4
        super.init(standardWindows: standardWindows)
    }
}

let fordCar = FordCar(standardWindows: 3)
fordCar.windows

这里需要注意的是，子类重载必须初始化的时候，还是需要遵从两段式初始化规定，即在super.init前初始化新的属性，在super.init后才能使用属性和方法。

如果protocol有指定初始化方法，那里实现这个protocol的类要使用必须初始化实现这个protocol指定的初始化方法，比如下面的代码编译不过：

protocol CarType {
    init(standardWindows: Int)
}

class Car: CarType {
    let wheel: Int = 4
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }
    init(standardWindows: Int = 4) {
        self.windows = standardWindows
    }  
}  // Initializer requirement 'init(standardWindows:)' can only be satisfied by a 'required' initializer in non-final class 'Car'

在第二个init前加入关键字required就通过了。

这里也解释了为什么继承很多UIKit的类（比如UITableViewCell），需要添加required init?(coder aDecoder: NSCoder)的原因，因为这些UIKit的类实现了NSCoding protocol，比如UITableViewCell就实现了NSCoding protocol，NSCoding protocol中有指定初始化方法：

public protocol NSCoding {

    
    func encode(with coder: NSCoder)

    init?(coder: NSCoder) // NS_DESIGNATED_INITIALIZER
}

便利初始化（convenience initializers）

可以在init前加入convenience关键字便可实现便利初始化，便利初始化可以调用其他的便利初始化，但最终中必须调用一个非便利的初始化，比如：

class Car {
    let wheel: Int = 4
    let windows: Int
    init(windows: Int) {
        self.windows = windows
    }
    convenience init(standardWindows: Int = 4) {
        self.init(windows: standardWindows)
    }
}

便利初始化不能被子类调用，不用遵循两段式初始化的规则。

指定初始化（designated initializer）

指定初始化（designated initializer）其实就是非便利初始化，包括常规的初始化init和必须初始化required initializer，遵循两段式初始化的规则。

总结

说了这么多，其实初始化的方法可以总结如下：

类初始化必须完成的一个任务就是让所有的存储属性都有初始值（optional 除外）。
如果父类有指定初始化，子类必须也有指定初始化，并且必须调用父类的其中一个指定初始化（如果是必须初始化，就是重载），并遵循两段式初始化的规则。
一个便利初始化必须调用同一类中的初始化方法（可以是另一个便利初始化，也可以是指定初始化），但最终一定会调用到一个指定初始化。
便利初始化不遵循两段式初始化的规则，不能被子类调用或者重载。

Swift类和子类的初始化总结

两段式初始化（ two-phase initialization）

必须初始化 （Required initializers）

便利初始化（convenience initializers）

指定初始化（designated initializer）

总结

必须初始化（Required initializers）