一、初始化器的重写

1、子类重写父类的指定初始化器

class Person {
    init(age:Int) {
    }
}

class student :Person{
    override init(age:Int) {
        super.init(age: 20)
    }
}

class Person {
    init(age:Int) {
    }
}

class student :Person{
    init(age:Int,score:Int) {
        super.init(age: 20)
    }
    convenience override init(age: Int) {
        self.init(age:20,score:40)
    }
}

• 当重写父类的指定初始化器时，必须加上override(即使子类的实现是便捷初始化器)

2、子类写了一个匹配父类的便捷初始化器

class Person {
    init(age:Int) {

    }
    
    convenience init(weight:Int){
        self.init(age: 20)
    }
}

class student :Person{
    init(age:Int,score无法:Int) {
        super.init(age: 20)
    }
    
    convenience init(weight: Int) {
        self.init(age:20,score:40)
    }
}

• 子类写了一个匹配父类的便捷初始化器的初始化器，不用加override。因为父类的便捷初始化器永远不会通过子类直接调用，因此，严格来说，子类无法重写父类的便捷初始化器

二、初始化器的自动继承

• 1、如果子类没有自定义任何指定初始化器，它指定会自动继承父类的所有指定初始化器。

class Person {
    
    init(age:Int) {
        print(“年龄”)
    }
    
    init(weight:Int) {
  
    }
    init(weight:Int,age:Int) {
    }
}
class student :Person{
}
let p = Person(age: 12)
let p1 = Person(weight: 20)
let p2 = Person(weight: 20, age: 10)

子类只要自定义了，就不会继承了。

• 2、如果子类提供了父类所有指定初始化器的实现（要么通过继承，要么通过重写），子类自动继承所有的父类便捷初始化器。

通过继承：

class Person {
    
    init(age:Int) {
        print(“年龄”)
    }

    convenience init(sex:String){
        self.init(age:30)
    }
}

class Student :Person{

}
let s = Student(sex:”男”)

通过重写：

class Person {
    
    init(age:Int) {
        print(“年龄”)
    }

    convenience init(sex:String){
        self.init(age:30)
    }
    
}

class Student :Person{
    override init(age: Int) {
        super.init(age: 20)
    }
}
let s = Student(sex:”男”)

• 3、子类以便捷初始化器的形式重写父类的指定初始化器，也可以作为满足规则2的一部分

class Person {
    
    init(age:Int) {
        print(“年龄”)
    }

    convenience init(sex:String){
        self.init(age:30)
    }
    
}

class Student :Person{
    init() {
        super.init(age: 20)
    }
    
    convenience override init(age: Int) {
        self.init()
    }
}

let s = Student(sex:”男”)

三、required

用required修饰的指定初始化器，表明其所有子类都必须实现（通过继承或者重写）

class Person {
    required init(){
        
    }
}
class Student:Person{
    
}

class Person {
    required init(weight:Float){
        
    }
}

class Student:Person{
    init(age:Int) {
        super.init(weight: 12.0)
    }

    required init(weight: Float) {
  
        super.init(weight: 44)
        
    }
}

• 如果子类重写了required初始化器，也必须加上required,不用加overide

三、属性观察器

父类的属性在它自己的初始化器中赋值不会触发属性观察器，但在子类的初始器中会触发属性观察器

class Person {
    var age: Int{
        willSet{
            print("willSet",newValue)
        }
        didSet{
            print("didSet",oldValue)
        }
    }
    
    init() {
        self.age = 0
    }
    
}

class Student:Person{
    override init() {
        super.init()
        self.age = 10
    }
}
let s = Student()