Swift 5.1 (14) - 初始化和反初始化

时间 2020-04-16

标签 swift 5.1 初始化栏目 Swift 繁體版

原文原文链接

级别： ★☆☆☆☆
标签：「iOS」「Swift 」「便利初始化」「初始化」「反初始化」
做者：沐灵洛
审校： QiShare团队php

初始化`Initialization`

初始化是准备类，结构体或枚举类型实例的过程。该过程当中涉及：设置存储属性初始值，初始化实例所需的配置项。git

为存储属性设置初始值

由于在建立类或结构体的实例后，类或结构体的全部存储属性必需要要有初始值，故，在类和结构体定义时就必须为其全部存储属性设置适当的初始值。存储属性不能保留在不肯定的状态（无初始值的状态），不然编译器会提示咱们：Class '*' has no initializers。github

初始化方法中为存储属性设置初始值。

class Initializers {
    //! 属性声明时就设置属性的默认值
    var storeProperty : String = "变量存储属性声明时就设置属性的默认值"
    let constantStoreProperty : String = "常量存储属性声明时就设置属性的默认值"
    //! 属性声明为可选类型，可选类型的属性将自动初始化为nil
    var optionalProperty : Array<Int>?
}
复制代码

属性声明时指定默认属性值为其初始值。

class Initializers {
    var storeProperty : String
    let constantStoreProperty : String
    //! 属性声明为可选类型，可选类型的属性将自动初始化为nil。能够在初始化方法中设置其余值，也能够无论，看须要。
    var optionalProperty : Array<Int>?
    init() {
        storeProperty = "在初始化方法中设置了存储属性的初始值"
        constantStoreProperty = "在初始化方法中设置了常量存储属性的初始值"
    }
}
复制代码

####自定义初始化编程

class Initializers {
    var storeProperty : String
    let constantStoreProperty : String
    var optionalProperty : Array<Int>?
    // 无参数，无标签
    init() {
        storeProperty = "在初始化方法中设置存储属性的初始值"
        constantStoreProperty = "在初始化方法中设置常量存储属性的初始值"
    }
    //！有参数，有参数标签的自定义初始化方法
    init(prefixed prefix:String) {
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值"
        constantStoreProperty = prefix + "在初始化方法中设置常量存储属性的初始值"
    }
    //！有参数，无参数标签的自定义初始化方法
    init(_ prefix:String) {
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值"
        constantStoreProperty = prefix + "在初始化方法中设置常量存储属性的初始值"
    }
    //!多参数，有标签
    init(prefixed prefix:String, suffixed suffix:String) {
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值" + suffix
        constantStoreProperty = prefix + "在初始化方法中设置常量存储属性的初始值" + suffix
    }
    init(prefix:String,suffix:String) {
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值" + suffix
        constantStoreProperty = prefix + "在初始化方法中设置常量存储属性的初始值" + suffix
    }
    //! 多参数，无标签
    init(_ prefix:String, _ suffix:String) {
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值" + suffix
        constantStoreProperty = prefix + "在初始化方法中设置常量存储属性的初始值" + suffix
    }
    class func usage(){
        //!调用：有参数，有参数标签的自定义初始化方法
        let obj = Initializers("QiShare")
        print(obj.storeProperty + "\n" + obj.constantStoreProperty)
        //!调用：有参数，无参数标签的自定义初始化方法
        let obj1 = Initializers(prefixed: "hasArgumentLabels")
        print(obj1.storeProperty + "\n" + obj1.constantStoreProperty)
        //!调用：多参数，有参数标签的自定义初始化方法
        let obj2 = Initializers(prefixed: "QiShare", suffixed: "end")
        print(obj2.storeProperty + "\n" + obj2.constantStoreProperty)
        //!调用：多参数，无参数标签的自定义初始化方法
        let obj3 = Initializers("Qishare","end")
        print(obj3.storeProperty + "\n" + obj3.constantStoreProperty)
    }
}
复制代码

默认初始化方法

Swift 能够为任何结构体和类提供默认的初始化方法，前提是结构体或类中的全部属性都被赋了初始值，而且结构体和类也没有提供任何初始化方法。swift

结构体类型的成员初始化方法安全

若是结构类型没有定义任何自定义的初始化方法，它们会自动生成接收成员属性初始值的初始化方法。与结构体默认初始化方法不一样，即便结构体的存储属性没有默认值，结构体类型也会生成接收成员属性初始值的初始化方法。bash

struct Size {
    var width = 0.0
    var height : Double
}
//! 使用
let size1 = Size.init(width: 3.0, height: 3.0)
let size2 = Size(height: 3.0)
print(size1)
复制代码

注意：值类型中自定义了初始化方法，则将没法再访问该类型的默认初始化方法，或结构体自动生成的接收成员属性初始值的初始化方法。此约束为了保证自定义的初始化方法的优先级。微信

//自定义初始化方法
struct Size {
    var width = 0.0
    var height : Double
    init(wid:Double,hei:Double) {
        width = wid
        height = hei
    }
}
//原始生成的初始化方法失效
let size1 = Size.init(width: 3.0, height: 3.0) //< 报错
复制代码

值类型初始化方法嵌套调用`Initializer Delegation`

Initializer Delegation：值类型初始化方法中调用其余初始化方法来执行实例初始化的一部分。做用：避免跨多个初始化方法时出现重复代码。注意：初始化方法的嵌套调用在值类型和类类型中规则不一样。值类型（结构体和枚举）不涉及继承，相对简单。类类型涉及继承，咱们须要额外的操做，来保证明例对象初始化的正确性。闭包

struct Rect {
    var origin = Point()
    var size = Size()
    init() {}
    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}
复制代码

类继承和初始化

类的全部存储属性，包括类从其父类继承的任何属性，都必须在初始化期间分配初始值。Swift为类类型定义了两种初始化方法：指定初始化方法和便利初始化方法，来帮助确保类的全部存储属性都能设置初始值。ide

指定初始化方法和便利初始化方法

指定初始化方法：是类的主要初始化方法，负责彻底初始化类的全部属性，且会调用super引入父类适当的初始化方法。便利初始化方法：是类次要的初始化方法，便利初始化方法能够定义默认值做为初始化方法调用的参数值。方便咱们使用给定的默认值建立一个实例对象。

指定和便利初始化方法的语法

指定初始化方法：

init(`parameters`) {
}
复制代码

便利初始化方法：使用convenience关键字来指明

convenience init(`parameters`) {
    //statements
}
复制代码

类类型初始化方法嵌套调用Initializer Delegation

为了简化初始化方法与便利初始化方法之间的关系，Swift对于Initializer Delegation制定了三个规则：

指定初始化方法必须调用其直接父类的指定初始化方法。
便利初始化方法中必须调用同类的另外一个初始化方法。
便利初始化方法最终必须调用到指定的初始化方法。

class Animal {
    var name : String
    var kind : String = "Unknown"
    init(name:String = "[UnNamed]") {
        self.name = name
    }
    convenience init(name : String, kind : String) {
       /*便利初始化方法中必须调用同类的另外一个初始化方法
         便利初始化方法最终必须调用到指定的初始化方法
       */
        self.init(name: name)
        self.kind = kind
    }
}
class Dog: Animal {
    var nickName : String = "nihao"
    init(name : String, kind : String) {
        //指定初始化方法中，不能调用父类的便利初始化方法
        //super.init(name: name, kind: kind) // error:Must call a designated initializer of the superclass 'Animal'
        super.init(name: name)
    }
}

复制代码

总结：指定初始化方法必须始终向上使用super代理父级的初始化。便利初始化方法必须始终横向使用self代理同类的初始化。

注意：这些规则不会影响类建立实例时的使用方式。上图中的任何初始值方法都能用于建立彻底初始化的实例。规则仅影响类初始方法的实现方式。

下图会经过多类的复杂继承，来阐述指定初始化方法如何在类的初始化过程当中扮演烟囱、漏斗的角色。

初始化的两个阶段

第一阶段，设置全部存储属性的初始状态，赋初值。
第二阶段，有机会进一步定制其存储属性。

Swift的编译器为确保完成这两个阶段的初始化而没有错误，会执行如下四个安全检查：

指定初始化方法必须确保使用super向上代理父级初始化方法以前，完成初始化本类的全部属性。
指定初始化方法中为继承属性赋值以前，必须使用super向上代理父级初始化方法。不然继承属性的新值会因调用父级super初始化方法而覆盖。
便利初始化方法中为任何属性赋值以前，必须先调用同类的指定初始化方法。不然会被覆盖。
初始化的第一阶段完成以前，不能在初始化方法中调用本类的任何实例方法，读取来自父类的任何实例属性。即：不能引用self做为本类的一个实例对象。理解起来比较抽象，举个例子来阐述，示例以下：

class BaseClass {
    var property1 : String = "defaultvalue"
    var property2 : String
    init() {
        property1 = "property1"
        property2 = "property2"
    }
}
class SubClass: BaseClass {
    var property3 : String
    override init() {
        //property3 = "property3"
        //super.init()
        someInstanceMethod(property2)
        /*
         报错信息为：
         1.'self' used in method call 'someInstanceMethod' before 'super.init' call
         2.'self' used in property access 'property2' before 'super.init' call
         */
        someInstanceMethod(property3)
        /*
         报错信息为：
         1.'self' used in method call 'someInstanceMethod' before 'super.init' call
         2.Variable 'self.property3' used before being initialized
         */
    }
    func someInstanceMethod(_ : String) -> Void {
    }
}
复制代码

在第一阶段结束以前，类实例不彻底有效。

基于以上四个安全检查，以上两个阶段分别发挥的的做用总结以下：

第一阶段：

类的指定初始化方法或便利初始化方法会被调用。
为该类的新实例分配内存。内存还没有初始化。
类的指定初始化方法确认类中全部存储属性都具备值。至此全部存储属性的内存初始化完成。
类的指定初始化方法经过super委托父类的初始化方法完成父类全部存储属性的初始化。
类沿着继承链继续执行与4中相同的操做，直到继承链的顶端。
继承链中最顶端的类在确保其全部存储属性都有值时，意味着实例的内存已经彻底初始化。至此第一阶段完成。

第二阶段：

初始化方法中能够访问self并能够修改其属性，调用实例方法等。
便利初始化方法中能够选择自定义实例而且使用self。

class convenienceClass: Initializers {
    /* 初始化与指定初始化之间的关系
     必须调用父类的指定初始化方法
     便利初始化方法只能使用`self.init`代理类的初始化而不是使用`super.init`
     便利初始化方法必须最终调用到同类的指定初始化方法*/
    var subClassStoreProperty : String
    override init(prefixed prefix:String) {
        subClassStoreProperty = "子类的属性"
        super.init(prefix)
        storeProperty = prefix + "在初始化方法中设置存储属性的初始值"
    }
    //父类中有相应的初始化方法 须要`override`
    convenience override init(_ name : String = "子类便利初始化前缀",_ suffix : String = "子类便利初始化后缀") {
        self.init(prefixed: name) //!< 必须是同类的初始化方法
        self.storeProperty = "子类的便利初始化中的存储属性从新赋值"
    }
}
复制代码

初始化方法继承和重写

子类对父类初始化方法的覆盖或重写：子类提供了与父类相同的初始化方法。必需要使用override修饰。注意：即便是子类将父类的指定初始化方法实现为便利初始化方法也须要使用override修饰。

关于继承：与Objective-C不一样，Swift中子类默认状况下是不会继承父类的初始化方法的。只有在某些特定的状况下才会继承。

class Animal {
    var name : String
    init(name:String = "[UnNamed]") {
        self.name = name
    }
}
class Dog: Animal {
    var nickName : String
    init(others:String) {
        self.nickName = others
    }
}
//调用父类的初始化方法会报错。
//let dog = Dog.init(name:"nihao")
let dog = Dog.init(others:"nihao")
print(dog.name) // 打印[UnNamed]
复制代码

注意：关于隐式调用父类的初始化方法，即省略super.init()：当父类的指定初始化方法为零参数时，子类在其初始化方法中对其存储属性赋初值后，能够省略super.init()。

class Animal {
    var name : String = "defaultValue"
  //如下参数赋初值也是符合`零参数`规则，调用时也能够对该参数进行忽略。该方法不写也是对的。
    init(name:String = "[UnNamed]") {
        self.name = name
    }
}
class Dog: Animal {
    var nickName : String
    init(others:String) {
        self.nickName = others
        //super.init(),此处能够省略
    }
}
//调用
let animals = Dog.init(others: "狗")
print(animals.name) // [UnNamed]
复制代码

自动继承初始化方法

自动继承初始化方法意味着不须要override进行重写。前提：子类引入的新属性都确保提供了默认值。基于前提需遵照两个规则：

规则一：若是子类没有定义任何指定的初始化方法，则子类将自动继承其父类中全部的指定初始化方法,也会继承便利初始化方法。

class Animal {
    var name : String = "defaultValue"
    var kind : String = "Unknown"
    init(name:String = "[UnNamed]") {
        self.name = name
    }
    convenience init(name : String, kind : String) {
        self.init(name: name)
        self.kind = kind
    }
}
class Dog: Animal {
    var nickName : String = "defaultValue"
}
//子类使用继承自父类的便利初始化方法
let animals = Dog.init(name: "狗", kind: "狗类")
//子类使用继承自父类的指定初始化方法
let animals1 = Dog.init(name: "狗")
print(animals.name,animals1.kind)//!< 狗 Unknown
复制代码

规则二：若是子类提供了全部父类指定初始化方法的实现。则子类会自动继承全部父类的便利初始化方法。在子类对于父类全部指定初始化方法的实现中，加入咱们自定义的部分也是能够的。

class Animal {
    var name : String = "defaultValue"
    var kind : String = "Unknown"
    init(name:String = "[UnNamed]") {
        self.name = name
    }
    init(name2:String) {
        self.name = name2
    }
    convenience init(name : String, kind : String) {
        self.init(name: name)
        self.kind = kind
    }
}
class Dog: Animal {
    var nickName : String
    override init(name:String = "[UnNamed]") {
        self.nickName = "默认昵称"
        super.init(name: name)
        self.name = "自定义实现为：哈士奇"
    }
    override init(name2:String) {
        self.nickName = "默认昵称"
        super.init(name2: name2)
        self.name = "自定义实现为：哈士奇2"
    }
}
//子类使用继承自父类的便利初始化方法
let animals = Dog.init(name: "狗", kind: "狗类")
//子类使用继承自父类的指定初始化方法
let animals1 = Dog.init(name: "狗")
print(animals.name,animals1.kind)//!< 自定义实现为：哈士奇 Unknown
复制代码

注意点：子类能够将父类指定的初始化方法实现为子类便利初始化方法，也是知足规则二的。

class Animal {
    var name : String = "defaultValue"
    var kind : String = "Unknown"
    init(name:String = "[UnNamed]") {
        self.name = name
    }
    init(name2:String) {
        self.name = name2
    }
    convenience init(name : String, kind : String) {
        self.init(name: name)
        self.kind = kind
    }
}
class Dog: Animal {
    var nickName : String
    convenience override init(name:String = "[UnNamed]") {
        self.init(name2: name)
        self.nickName = "默认昵称"
        self.name = "自定义实现为：哈士奇"
    }
    override init(name2:String) {
        self.nickName = "默认昵称"
        super.init(name2: name2)
        self.name = "自定义实现为：哈士奇2"
    }
}
//子类使用继承自父类的便利初始化方法
let animals = Dog.init(name: "狗", kind: "狗类")
//子类使用继承自父类的指定初始化方法
let animals1 = Dog.init(name: "狗")
print(animals.name,animals1.kind)//!< 自定义实现为：哈士奇 Unknown
复制代码

实操中的指定和便利初始化方法

如下示例定义了三个类，分别为Food，RecipeIngredient和ShoppingListItem它们之间为继承关系。将用来展现指定初始化方法、便利初始化方法以及自动继承初始化方法之间的相互做用。

class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

class RecipeIngredient: Food {
    var quantity: Int
    init(name: String, quantity: Int) {
        self.quantity = quantity
        super.init(name: name)
    }
    override convenience init(name: String) {
        self.init(name: name, quantity: 1)
    }
}

class ShoppingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\(quantity) x \(name)"
        output += purchased ? " ✔" : " ✘"
        return output
    }
}
复制代码

初始化方法之间的做用解释以下：

Food为基类，定义了一个指定初始化方法init(name: String)和一个便利初始化方法convenience init()。

RecipeIngredient继承自Food：

定义了属于本身的初始化方法：init(name: String, quantity: Int)并在其中代理实现了父类的初始化super.init(name: name)。此处符合初始化的第一阶段：设置全部存储属性的初始状态，赋初值。
将父类的指定初始化方法实现为便利初始化方法：override convenience init(name: String)。该类在初始化的过程当中，能够确保自增的属性quantity有初值；而且init(name: String)为父类Food的惟一指定初始化方法。这点知足了自动继承初始化方法的规则二：若是子类提供了全部父类指定初始化方法的实现，则子类会自动继承全部父类的便利初始化方法。故该类继承了父类的便利初始化方法convenience init()。

ShoppingListItem继承自RecipeIngredient，未提供任何指定的初始化方法，此处知足了自动继承初始化方法的规则一：若是子类没有定义任何指定的初始化方法，则子类将自动继承其父类中全部的指定初始化方法,也会继承便利初始化方法。

因此构建RecipeIngredient和ShoppingListItem的实例能够经过如下三种方式：

RecipeIngredient(),
RecipeIngredient(name: "醋"),
RecipeIngredient(name: "大葱", quantity: 6)
//`ShoppingListItem`的实例
ShoppingListItem(),
ShoppingListItem(name: "姜"),
ShoppingListItem(name: "鸡蛋", quantity: 6)
复制代码

以上阐述能够用一张图来展现：

可失败的初始化方法

使用init?来声明一个class，structure或enumeration可失败的初始化方法。这种失败可能会被无效的初始化参数，必要资源的缺乏等阻碍初始化成功的条件触发。

须要注意的是：

不能使用相同的参数类型和名称既定义可失败的又定义不可失败的初始化方法。
可失败的初始化方法将建立该类型的可选值，经过在可失败的初始化方法中return nil来表示初始化失败的条件被触发了。

class Animal {
    var name : String 
    init?(name:String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}
if let _  = Animal.init(name: "") {
    print("初始化成功")
} else {
    print("初始化失败")//!< 输出
}
复制代码

枚举类型可失败的初始化方法

enum ResponseStatus {
    case ResponseStatus(Int,String)
    case ResponseFail
    case ResponseSuccess
    init?(code: Int,des:String){
        switch code {
        case 401:
             self = .ResponseStatus(code,des)
        case 500:
            self = .ResponseFail
        case 200:
            self = .ResponseSuccess
        default:
            return nil
        }
    }
}
//调用
if let status = ResponseStatus.init(code: 401, des: "未受权") {
    switch status {
    case .ResponseStatus(let code, let status):
        print(code,status) //401 未受权
    default:
        print("失败了")
    }
}
复制代码

具备原始值的枚举的可失败的初始化方法

enum Direction: Int {
    case east = 0,west = 1, south = 2, north = 3
}
//调用
if let dir = Direction.init(rawValue: 2) {
    print(dir.self) //!< south
} else {
    print("失败了")
}
复制代码

初始化失败的传播

值类型，类类型均可以使用初始化方法的委托，能够是同类委托，也能够是子类委托父类，不论是何种方式，若咱们委托的初始化方法形成了初始化失败，整个初始化的过程会当即失败，不会再继续执行。注意：可失败的初始化方法也能够委托一个不可失败的初始化方法，使用这种方式，咱们须要在初始化的过程当中添加潜在的失败操做，不然将不会失败。

class Animal {
    var name : String = "defaultValue"
    init(name:String) { //加问号也行
        self.name = name
    }
}
class Dog: Animal {
    var kind : String
    init?(name : String, kind : String) {
        if kind.isEmpty {
            return nil
        }
        self.kind = kind
        super.init(name: name)
    }
}
//调用
if let _ = Dog.init(name: "", kind: "") {
    print("初始化成功")
} else {
    print("初始化失败")//!< 输出
}
复制代码

重写可失败的初始化方法

子类能够重写父类可失败的初始化方法。子类也能够将其重写为不可失败的初始化方法来使用：意味着父类中此方法可fail，重写后便不可fail。

注意：

能够将可失败的初始化方法覆盖为不可失败的初始化方法，但不能反过来。
将可失败的初始化方法覆盖为不可失败的初始化方法时，委托父类可失败的初始化方法时，须要强制解包可用的父类初始化结果。

class Animal {
    var animalName : String = "defaultValue"
    init?(name:String) {
        if name.isEmpty { return nil }
        animalName = name
    }
}
class Dog: Animal {
    var kind : String
    override init(name:String) {
        kind = "defaultKind"
        //处理父类可能初始化失败的状况
        if name.isEmpty {
            super.init(name: "[UnKnown]")!
        } else {
            super.init(name: name)!
        }
    }
}
//调用
let dog = Dog.init(name: "")
print(dog.animalName)
复制代码

init!可失败的初始化方法

定义一个可失败的初始化程序，经过关键字init?。当定义一个可失败的初始化方法，用于建立相应类型的隐式解包的可选实例时，经过关键字init!。能够在init!中委托init?,反之亦然，能够重写init?为init!反之亦然；也能够在init中委托init!，这样作，在init!初始化失败时，会触发断言。

必需的初始化方法

使用required关键字，来表示每一个子类都必须实现该初始化方法。

class SomeClass {
    required init() {
    }
}
复制代码

子类在实现必需的初始化方法时，也必须使用required关键字来表示这个必需的初始化方法也适用于继承链中的其余子类。

class SomeSubclass: SomeClass {
    required init() {
        //super.init()
    }
}
复制代码

注意：若知足初始化方法的继承条件，则没必要显式实现required修饰的初始化方法。

使用闭包或函数设置默认属性值

若是存储属性的默认值须要某些自定义或设置，则可使用闭包或全局函数为该属性提供自定义的默认值。每当初始化属性所属类型的新实例时，将调用闭包或函数，并将其返回值指定为属性的默认值。

使用闭包赋值的形式，函数与之相似：

class SomeClass {
    let someProperty: SomeType = {
        // `someValue` 必须是` SomeType`类型
        return someValue
    }()
}
复制代码

注意：若是使用闭包来初始化属性，须要注意在执行闭包时还没有初始化实例的其他部分。意味着没法从闭包中访问任何其余属性值，即便这些属性具备默认值也是如此。也不能使用隐式self属性和调用任何实例的方法。

反初始化`Deinitialization`

Deinitialization能够理解为对象析构函数与对象初始化对应，在释放对象内存以前调用。当对象结束其生命周期，调用析构函数释放内存。Swift中经过自动引用计数处理实例的内存管理。注意：

析构函数在实例释放内存以前自动调用，不容许手动调用。
父类的析构函数被子类继承，并在子类对析构函数的实现调用结束后自动调用。即便子类不提供本身的析构函数，父类的析构函数也老是会被调用。

析构函数仅在类类型中有效，使用deinit关键字。写法：

deinit {
}
复制代码

参考资料： swift 5.1官方编程指南

了解更多iOS及相关新技术，请关注咱们的公众号：

小编微信：可加并拉入《QiShare技术交流群》。

关注咱们的途径有：
QiShare(简书)
QiShare(掘金)
QiShare(知乎)
QiShare(GitHub)
QiShare(CocoaChina)
QiShare(StackOverflow)
QiShare(微信公众号)

推荐文章：
浅谈编译过程
 深刻理解HTTPS 浅谈 GPU 及 “App渲染流程”
iOS 查看及导出项目运行日志
 Flutter Platform Channel 使用与源码分析
 开发没切图怎么办？矢量图标（iconFont）上手指南
 DarkMode、WKWebView、苹果登陆是否必须适配？
奇舞团安卓团队——aTaller
奇舞周刊