Swift中的构造函数及其继承

  在Swift中，继承只能发生在类身上，结构体和枚举是不能够被继承的。一个类可以继承另一个类的方法、属性和下标。当一个类继承自另一个类时，这个类就被称之为子类，而被继承的类则被称之为父类(超类)。子类可以重写父类的方法、属性和下标。

  在Objective-C中，所有的类都继承自NSObject，而Swift中的类可以没有父类。没有父类的类被称之为基类。NSObject就是Objective-C中所有其它类的基类，而Swift中并没有这样的基类。

  通常情况下，一个类只能继承自一个父类，这被称之为单继承。但是，有些时候一个类可以继承自多个类，这种情况被称之为多重继承。Swift中的类只能是单继承，而多重继承则是通过协议来实现的。也就说，Swift中的类只能继承自一个父类，但是它可以遵守多个协议，从而达到类似于多重继承的效果。

  1、构造函数的继承

  我们在上一篇文章《Swift中的构造方法》里讲构造函数代理时，提到过便利构造函数和指定构造函数，其实根据继承关系，类里面的构造函数代理又分为横向代理和向上代理。所谓的横向代理，就是指发生在同一个类中的构造函数代理，也就是我们在前面所说的便利构造函数；而向上代理是指子类在构造过程中，要先调用父类的构造函数来初始化父类的存储属性，这也就是我们所说的指定构造函数。

  下面我们来看一个具体的示例，在父类Person中，我们通过调用它自己的构造函数来实现便利构造函数，然后在子类Student中调用指定构造函数来完成父类存储属性的初始化：

// 类的构造函数
class Person {
    var age: Int
    var name: String
    
    // 父类构造函数1：在构造函数中初始化存储属性
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    // 父类构造函数2：调用自己的构造函数(便利构造函数)
    convenience init(A age: Int, N name: String) {
        self.init(age: age, name: name)
    }
}

class Student: Person {
    var no: Int
    var height: Double
    
    // 子类构造函数1：子类自己的构造函数
    init(age: Int, name: String, no: Int, height: Double) {
        
        // 先初始化自己的存储属性
        self.no = no
        self.height = height
        
        // 再向上调用父类的构造函数1, 对父类的存储属性进行初始化(指定构造函数)
        super.init(age: age, name: name)
    }
    
    // 子类构造函数2：重写父类的构造函数
    convenience override init(age: Int, name: String) {
        
        // 调用自己的构造函数1来完成初始化工作(便利构造函数)
        self.init(age: age, name: name, no: 0, height: 0.0)
    }
}

let p = Person(age: 20, name: "Paul")  // p.age = 20, p.name = Paul
print("p.age = \(p.age), p.name = \(p.name)")

let stu = Student(age: 22, name: "James", no: 1701, height: 1.72)
// stu.age = 22, stu.name = James, stu.no = 1701, stu.height = 1.72
print("stu.age = \(stu.age), stu.name = \(stu.name), stu.no = \(stu.no), stu.height = \(stu.height)")

  构造函数之间的调用形成了构造函数链，而这个调用规则是有一定限制的。具体应遵守的规则如下：

• 在使用指定构造函数时，必须调用其直接父类的构造函数。也就是说，在调用父类的构造函数初始化父类的存储属性时，不能调用父类的父类的构造函数，应该调用直接父类的构造函数；

• 在使用便利构造函数时，必须调用同一个类中定义的其它构造函数。这个应该很好理解，不用做过多的解释。

  2、构造过程安全检查

  在Swift中，类的构造过程包含两个阶段：首先分配内存，初始化子类的存储属性，然后沿着构造函数链往上，初始化父类的存储属性，直到最顶端父类的所有存储属性都初始化完毕；接着，从构造函数链最顶端往下，对每一个类的存储属性进行修改、调用实例方法，直到所有的类都处理完毕。Swift的编译器在构造过程中会进行一些安全检查，它可以有效的防止存储属性在初始化之前被访问，还可以防止存储属性被另外一个构造函数赋予不同的值。Swift提供了4中安全检查机制，接下来我将做一一说明和演示。

  (1)、指定构造函数必须保证其所在类中所有的存储属性都完成初始化之后，才能向上调用父类的构造函数。也就是说，如果你先调用父类的构造函数，然后再初始化当前类中的存储属性，编译器会报错：

class Student: Person {
    var no: Int
    var height: Double
    
    init(age: Int, name: String, no: Int, height: Double) {
        
        // 没有先初始化自己的存储属性，然后再调用指定构造函数，编译器会报错
        super.init(age: age, name: name)  
        
        // 初始化自己的存储属性
        self.no = no
        self.height = height
    }

    convenience override init(age: Int, name: String) {

        self.init(age: age, name: name, no: 0, height: 0.0)
    }
}

  (2)、指定构造函数必须先向上调用父类的构造函数，然后再为继承的属性设置新的值，否则指定构造函数赋予的新值将会被父类构造函数赋予的值给覆盖。也就是说，如果你希望给继承的属性赋一个新值，应该将赋值语句放在指定构造函数后面，否则赋予的新值将会被指定构造函数所覆盖，从而造成赋新值失败：

class Student: Person {
    var no: Int
    var height: Double

    init(age: Int, name: String, no: Int, height: Double) {
        
        self.no = no
        self.height = height
        
        // 在调用指定构造函数之前给继承的属性age赋新值，这个会失败
        self.age = 35
        
        // 向上调用父类的构造函数, 对父类的存储属性进行初始化(指定构造函数)
        super.init(age: age, name: name)
        
        // 先调用指定构造函数，然后再为继承的属性赋新值，这个可以成功
        self.name = "Wade"
    }

    convenience override init(age: Int, name: String) {

        self.init(age: age, name: name, no: 0, height: 0.0)
    }
}

  (3)、便利构造函数必须先调用自己所在类中的其它构造函数，然后才能给任意属性(包括从父类继承的属性)赋予新值，否则便利构造函数赋予的新值将会被同一类中的其它构造函数所覆盖。也就是说，如果你想在便利构造函数中给属性赋新值，则应该先调用其它构造函数，然后再为属性赋新值，否则新值将会被其它构造函数所覆盖；

class Student: Person {
    var no: Int
    var height: Double

    init(age: Int, name: String, no: Int, height: Double) {

        self.no = no
        self.height = height

        super.init(age: age, name: name)
    }

    convenience override init(age: Int, name: String) {
        
        // 在便利构造函数中，先给自己的属性赋新值，然后再调用其它构造函数
        self.height = 2.999999999  // 这个会失败
        
        // 调用自己的构造函数完成初始化工作(便利构造函数)
        self.init(age: age, name: name, no: 0, height: 0.0)
        
        // 在便利构造函数中，先调用所在类中的其它构造函数，然后再给自己的属性赋值
        self.no = 188888888  // 这个可以成功
    }
}

  (4)、构造函数在第一阶段完成之前，不能调用实例方法，也不能读取实例属性。也就是说，必须保证子类和父类的所有存储属性都被初始化完成之后，才能调用实例方法，访问实例的属性。

class Student: Person {
    var no: Int
    var height: Double

    init(age: Int, name: String, no: Int, height: Double) {

        self.no = no
        self.height = height
        
        // 指定构造方法还没有执行，父类的属性还没有初始化，这里不能访问父类的属性
        self.getName(name: name)
        
        // 向上调用父类的构造函数, 对父类的存储属性进行初始化(指定构造函数)
        super.init(age: age, name: name)
        
        // 指定构造方法执行完之后，父类的name属性已经被初始化了，这里可以调用
        self.getName(name: name)
    }

    convenience override init(age: Int, name: String) {

        self.init(age: age, name: name, no: 0, height: 0.0)
    }
    
    // 实例方法
    func getName(name: String) {
        
        print("name = \(name)")
    }
}

  3、构造函数的继承

  在Swift中，子类的构造函数有两种来源，首先是自己拥有的构造函数，其次是从父类中继承过来的构造函数。但是，比不是所有父类构造函数都能够被子类继承。子类继承父类的构造函数是有条件的：

• 如果子类中没有任何构造函数，那么它将自动继承父类中所有的指定构造函数；

• 如果子类中实现了父类所有的指定构造函数，那么它都将自动继承父类所有的便利构造函数。

  4、关键字final

  在定义一个类时，可以使用关键字final声明类、属性、方法和下标。被final关键字修饰的类不能够被继承，被final关键字修饰的属性、方法和下标不能够被子类重写。