类的初始化和反初始化

初始化器

• 初始化器在创建特定类型的实例时被调用。

struct Fahrenheit {
    var temperature : Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)")

执行结果如下：
The default temperature is 32.0

默认的属性值

• 如上所述，你可以在初始化器里为存储属性设置初始值。另外，指定一个默认属性值作为属性声明的一部分。当属性被定义的时候，你可以通过为这个属性分配一个初始值来指定默认的属性值。

struct Fahrenheit {
    var temperature = 32.0
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)")

默认的初始化器

• Swift 为所有没有提供初始化器的结构体或类提供了一个默认的初始化器来给所有的属性提供了默认值。这个默认的初始化器只是简单的创建了一个所有属性都有默认值的新实例。

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

自定义初始化

• 可以提供初始化形式参数作为初始化器的一部分，来定义初始化过程中的类型和值得名称。初始化形式参数与函数和方法的形式参数有相同的功能和语法。

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

在初始化中分配常量属性

• 在初始化的任意时刻，你都可以给常量属性赋值，只要它在初始化结束时设置了确定的值即可。一旦常量属性被赋值，它就不能再被修改了。

class surveryQuestion {
    let text :String
    var response : String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
let beetsQuestion = surveryQuestion(text: "How about beets?")
beetsQuestion.ask()
beetsQuestion.response = "I also like beets. (But not with cheese.)"
beetsQuestion.ask()

执行结果如下：
How about beets?
How about beets?

结构体的成员初始化器

• 如果结构体类型中没有定义任何自定义初始化器，它会自动获得一个成员初始化器。不同于默认初始化器，结构体会接收成员初始化器即使它的存储属性没有默认值。

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

值类型的初始化器委托

• 初始化器可以调用其他初始化器来执行部分实例的初始化。这个过程，就是所谓的初始化器委托，避免了多个初始化器里冗余代码。

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
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)
    }
}

类的继承和初始化

制定初始化器和便捷初始化器

• 用与值类型的简单初始化器相同的方式来写类的指定初始化器
• 用 convenience 修饰符放到 init 关键字前定义便捷初始化器

类的初始化委托

• 指定初始化器必须从它的直系父类调用指定初始化器
• 便捷初始化器必须从相同的类型里调用另一个初始化器
• 便捷初始化器最终必须调用一个指定初始化器

两段式初始化

安全检查

两段式初始化过程-阶段1

两段式初始化过程-阶段2

初始化器的继承和重写

初始化器的自动继承

• 如果你的子类没有定义任何指定初始化器，它会自动继承父类所有的指定初始化器。
• 如果你的子类提供了所有父类指定初始化器的实现--要么是通过规则1继承来的，要么通过在定义中提供自定义实现的--那么它自动继承所有父类便捷初始化器。

可失败初始化器

• 定义类、结构体或枚举初始化时可以失败在某些情况下会管大用。这个失败可能由以下几种方式触发，包括给初始化传入无效的形式参数值，或缺少某种外部所需的资源，又或是其他阻止初始化的情况。
• 为了妥善处理这种可能失败的情况，在类、结构体或枚举中定义一个或多个可失败的初始化器。通过 init 关键字后面添加问号（init？）来写。

必要初始化器

• 在类的初始化器前添加 required 修饰符来表明所有该类的子类都必须实现该初始化器。

反初始化

• 在类实例被释放的时候，反初始化器就会立即被调用。你可以是用 deinit 关键字来写反初始化器，就如同写初始化器要用 init 关键字一样。反初始化器只在类类型中有效。
• 反初始化器会在实例被释放之前自动被调用。你不能自行调用反初始化器。父类的反初始化器可以被子类继承。并且子类的反初始化器实现结束之后父类的反初始化器会被调用。父类的反初始化器总会被调用，就算子类没有反初始化器。

反初始化器

• 每个类中只能有1个反初始化器。反初始化器不接受任何形式参数，并且不需要写圆括号。

deinit {
        
}