Language Guide --- Initializatio

作者: 岛主_changdao | 来源:发表于2017-11-08 19:15 被阅读0次

实例化是准备类、结构体、枚举的一个实例的过程。与OC不同的是，Swift的init方法没有返回值。

Setting Initial Values for Stored Properties

类和结构体实例在创建之前必须要给它们的存储属性设置一个合适的初始值。
可以在init方法里给存储属性设置一个初值，也可以在声明属性的时候给一个初值。这两种情况都不会触发属性的observer。

Initializers

init方法看起来跟没有参数的实例方法一样，使用init关键字。

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()

Default Property Values

如果某个存储属性总是使用同一个初值，最好在声明的时候就给它赋值。这样不仅能推断出该属性的类型，还能够使init方法更简短更清晰。而且给属性设置默认值能够使默认init方法和init继承更简单。

Customizing Initialization

可以使用输入参数自定义初始化过程。

Initialization Parameters

可以提供参数作为init方法定义的一部分。初始化参数的语法跟函数方法参数语法相同。

struct Celsius {
    var temperatureInCelsius: Double
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
}

let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
let freezingPointOfWater = Celsius(fromKelvin: 273.15)

Parameter Names and argument Labels

如果某个类有多个init方法，我们只能通过参数标签来区分调用的是哪个init方法。如果我们没有提供参数标签，Swift会自动为我们提供。
一旦init方法有参数标签，调用的时候就不能省略，否则会导致编译错误。

Initializer Parameters Without Argument Labels

如果不行使用参数标签，需要明确使用 “_” 替代参数标签。

struct Celsius {
    var temperatureInCelsius: Double
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
    init(_ celsius: Double) {
        temperatureInCelsius = celsius
    }
}
let bodyTemperature = Celsius(37.0)

Optional Property Types

如果某个属性在init的时候不能确定它的值，或者这个属性允许没有值，那么可以被这个属性设置成optional。optional的属性在初始化的时候会被自动赋值成nil。
optional的属性可以在声明的时候不给初值，也不在init中复制。（其实在声明的时候，系统已经给了初值nil）

Assigning Constant Properties During Initialization

可以在初始化的任何时候给常量属性设置初值，只要是在初始化完成之前。常量属性只能在它所属的类中设置初值，不能在其子类中设置。

class SurveyQuestion {
    let text: String
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}

Default Initializers

Swift会给类和结构体提供一个默认的init方法。但这些类和结构体要满足条件：

它的所有属性都设置了初值
它自己没有提供init方法

默认的init方法就是使用初值创建一个实例。

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()

Memberwise Initializers for Structure Types

如果没有给结构体提供一个init方法，它会自动生成一个成员逐一赋值的init方法，即便结构体中的属性没有默认值。

struct Size {
    var width = 0.0, height = 0.0
}
let twoByTwo = Size(width: 2.0, height: 2.0)

Initializer Delegation for Value Types

init方法可以调用其他的init来执行一部分初始化工作，称为initializer delegation。
值类型（结构体和枚举）和类类型的初始化代理的规则是不同的。值类型的实例化代理比较简单，因为它们不能继承，它们只能使用它们自己的init方法代理。

对于值类型，可以使用self.init指向其他的init方法，而且只能在init方法内使用self.init。
一旦自定了init方法，就不能再使用默认init方法了。这样能够避免调用者使用默认init方法而不去使用开发者期待的init方法。

如果既想使用默认init又想使用我们自定义的init，可以在extension中自定义int方法。

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)
    }
}

Class Inheritance and Initialization

类的所有存储属性包括继承过来的，都必须在初始化的时候赋一个初值。
Swift有指定构造方法（designed initialization）和便利构造方法(convenience initialization)两种初始化方式保证存储属性都会有初值。

Designed Initialization and Convenience Initialization

指定构造方法是类的主要构造方法，它初始化类中的所有属性，并且调用父类中的恰当的构造方法，完成父类链中的初始化过程。

类至少有一个指定构造方法，通常情况下只有一个。

Syntax for Designated and Convenience Initializers

类的指定构造方法的写法跟值类型的构造方法一样。

init(parameters) {
     statements
}

便利构造方法的写法风格也相同，但是在init关键字前面有一个convenience,两者之间有一个空格。

convenience init(parameters) {
    statements
}

Initializer Delegation for Class Types

为了简化指定构造方法和便利构造方法之间的关系，Swift在构造方法代理方面有三条规则：

指定构造方法必须调用它的直接父类的指定构造方法
便利构造方法必须调用本类中的其他构造方法
便利构造方法必须最终调用到指定构造方法

屏幕快照 2017-11-08 16.07.09.png

Two-Phase Initialization

Swift的类的初始化有两个阶段。第一阶段，每一个存储属性被生声明它的类赋初值；第二阶段，每个类可以进一步的自定义它的存储属性。之后实例才能被使用。

Safety check 1
指定构造方法必须确保本类中的所有属性都被初始化了，才能调用父类的构造方法。

Safety check 2
指定构造方法在给继承过来的属性赋值前，必须先调用父类的构造方法。

Safety check 3
便利构造方法在给属性赋值前，必须调用其他构造方法。

Safety check 4
构造方法在第一阶段完成前不能调用实例方法，或者使用self作为一个值。

只有在第一阶段完成后，实例才是有效的，属性才能被获取，方法才能被调用。

安全检查是从下往上（子类到父类），自定义是从上到下（父类到子类）。

Initializer Inheritance and Overriding

跟OC不同Swift子类默认是不会继承父类的构造方法的。

当你在子类中定义了一个与父类指定构造方法匹配的构造方法时，必须要在该构造方法定义前使用override修饰，即便是父类的默认构造方法（默认构造方法总是被当作指定构造方法）。

使用override能够让Swift去检查父类中是否有匹配的指定构造方法，以及参数是否正确。

如果在子类中实现了一个与父类便利构造方法匹配的构造方法时，不需要使用override修饰。

Automatic Initializer Inheritance

子类默认是不会继承父类的构造方法的。但是，在某些情况下父类的构造方法会被自动继承。

如果本类（子类）声明的所有属性都有默认值，那么下面两条规则将适用：
Rule 1
如果子类没有定义指定构造方法，它会自动继承它所有父类的指定构造方法。

Rule 2
如果子类提供所有父类指定构造方法的实现（不管是通过上述规则1还是自己自定义了实现），它会自动继承所有父类的便利构造方法。

Designated and Convenience Initializers in Action

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

屏幕快照 2017-11-08 18.13.53.png

因为Food是基类（没有父类的概念），所以init不需要override标注。

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)
    }
}

RecipeIngredient 的init(name)与父类的指定构造方法匹配，需要override标注，即使它是便利构造方法。
RecipeIngredient的init(name: String, quantity: Int)给本类中所有属性赋值了，所以它是指定构造方法。
因为RecipeIngredient实现了所有父类的指定构造方法，所以它会继承所有父类的便利构造方法（就一个，init（））。

屏幕快照 2017-11-08 18.21.41.png

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

ShoppingListItem中的所有属性都有初值（description是计算属性）而且没有定义指定构造方法，它继承了所有父类的指定构造方法。又因为它有所有父类指定构造方法的实现，所以它继承所有父类的便利构造方法。如下图：

屏幕快照 2017-11-08 18.30.20.png

Failable Initializers

给类、结构体、枚举定义一个可以失败的构造方法有时候是有用的。在init关键字后加? 可以定义一个会失败的构造方法。

struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

Failable Initializers for Enumerations

enum TemperatureUnit {
    case kelvin, celsius, fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .kelvin
        case "C":
            self = .celsius
        case "F":
            self = .fahrenheit
        default:
            return nil
        }
    }
}

Failable Initializers forEnumerations with Raw Values

有raw value的枚举会自动接受一个可失败的构造方法，init?(rawValue:)。

Overriding a Failable Initializer

可以重写父类中的可失败的构造方法，设置可以重写成一个不会失败的构造方法。

可以使用强制展开，在子类的构造方法中调用父类的可失败的构造方法。

class UntitledDocument: Document {
    override init() {
        super.init(name: "[Untitled]")!
    }
}

Required Initializers

使用required修饰类的构造方法，表示所有子类都必须实现该构造方法。

class SomeClass {
    required init() {
        // initializer implementation goes here
    }
}

子类实现父类中的使用required修饰的构造方法时，也需要使用required标注，来表示这个规则需要在子类链中传递。不必使用override来修饰指定构造方法。

class SomeSubclass: SomeClass {
    required init() {
        // subclass implementation of the required initializer goes here
    }
}

init()是SomeClass的指定构造方法，在子类中有了required修饰，就不必使用override修饰了。