Swift4.2语言规范(十五) 继承

定义基类

任何不从其他类继承的类都称为基类。

下面的示例定义了一个名为的基类Vehicle。此基类定义一个名为的存储属性currentSpeed，其默认值为0.0（推断属性类型Double）。该currentSpeed属性的值由一个只读的计算String属性使用，该属性被调用description以创建车辆的描述。

所述Vehicle基类还定义了一个称为方法makeNoise。此方法实际上并不对基本Vehicle实例执行任何操作，但将由Vehicle以后的子类自定义：

1 class Vehicle {
2     var currentSpeed = 0.0
3     var description: String {
4         return "traveling at (currentSpeed) miles per hour"
5     }
6     func makeNoise() {
7         // do nothing - an arbitrary vehicle doesn‘t necessarily make a noise
8     }
9 }

您Vehicle使用初始化程序语法创建一个新实例，该语法写为类型名称，后跟空括号：

let someVehicle = Vehicle()

创建新Vehicle实例后，您可以访问其description属性以打印车辆当前速度的可读描述：

1 print("Vehicle: (someVehicle.description)")
2 // Vehicle: traveling at 0.0 miles per hour

在Vehicle类定义的共同特点为任意车辆，但没有太大用处本身。为了使其更有用，您需要对其进行优化以描述更具体的车辆类型。

子类

子类化是在现有类上创建新类的行为。子类继承现有类的特征，然后可以对其进行细化。您还可以向子类添加新特征。

要指示子类具有超类，请在超类名称之前写入子类名称，用冒号分隔：

1 class SomeSubclass: SomeSuperclass {
2     // subclass definition goes here
3 }

以下示例定义了一个名为的子类Bicycle，其超类为Vehicle：

1 class Bicycle: Vehicle {
2     var hasBasket = false
3 }

新的Bicycle类自动获得所有的特性Vehicle，例如它的currentSpeed和description特性及其makeNoise()方法。

除了它继承的特性之外，Bicycle该类还定义了一个新的存储属性，hasBasket其默认值为false（推断Bool属性的类型）。

默认情况下，Bicycle您创建的任何新实例都不会有篮子。您可以在创建该实例后为特定实例设置hasBasket属性：trueBicycle

1 let bicycle = Bicycle()
2 bicycle.hasBasket = true

您还可以修改继承的currentSpeed一个财产Bicycle实例，查询实例的继承description财产：

1 bicycle.currentSpeed = 15.0
2 print("Bicycle: (bicycle.description)")
3 // Bicycle: traveling at 15.0 miles per hour

子类本身可以是子类。下一个例子Bicycle为双座自行车创建一个子类，称为“串联”：

1 class Tandem: Bicycle {
2     var currentNumberOfPassengers = 0
3 }

Tandem继承了所有属性和方法Bicycle，从而继承了所有的属性和方法Vehicle。该Tandem子类还增加了一个新的存储属性调用currentNumberOfPassengers，用的默认值0。

如果您创建了一个实例Tandem，则可以使用其任何新的和继承的属性，并查询description它继承的只读属性Vehicle：

1 let tandem = Tandem()
2 tandem.hasBasket = true
3 tandem.currentNumberOfPassengers = 2
4 tandem.currentSpeed = 22.0
5 print("Tandem: (tandem.description)")
6 // Tandem: traveling at 22.0 miles per hour

重写

子类可以提供自己的实例方法，类型方法，实例属性，类型属性或下标的自定义实现，否则它将从超类继承。这被称为重写。

要覆盖否则将继承的特性，请使用override关键字为覆盖定义添加前缀。这样做可以澄清您打算提供覆盖并且没有错误地提供匹配的定义。意外覆盖可能会导致意外行为，并且override在编译代码时，没有关键字的任何覆盖都会被诊断为错误。

该override关键字还会提示Swift编译器检查您的重写类的超类（或其父类之一）是否具有与您为重写提供的声明匹配的声明。此检查可确保您的重写定义正确无误。

1 class Train: Vehicle {
2     override func makeNoise() {
3         print("Choo Choo")
4     }
5 }

1 let train = Train()
2 train.makeNoise()
3 // Prints "Choo Choo"

1 class Car: Vehicle {
2     var gear = 1
3     override var description: String {
4         return super.description + " in gear (gear)"
5     }
6 }

1 let car = Car()
2 car.currentSpeed = 25.0
3 car.gear = 3
4 print("Car: (car.description)")
5 // Car: traveling at 25.0 miles per hour in gear 3

1 class AutomaticCar: Car {
2     override var currentSpeed: Double {
3         didSet {
4             gear = Int(currentSpeed / 10.0) + 1
5         }
6     }
7 }

1 let automatic = AutomaticCar()
2 automatic.currentSpeed = 35.0
3 print("AutomaticCar: (automatic.description)")
4 // AutomaticCar: traveling at 35.0 miles per hour in gear 4

防止覆盖

您可以通过将方法，属性或下标标记为final来阻止它被覆盖。通过写做到这一点final的方法，属性，或标的介绍人关键字之前修饰符（如，，，和）。final?varfinal?funcfinal?class?funcfinal?subscript

任何覆盖子类中的最终方法，属性或下标的尝试都会报告为编译时错误。您添加到扩展中的类的方法，属性或下标也可以在扩展的定义中标记为final。

您可以通过在类定义（final?class）中的final?class关键字之前编写修饰符来将整个类标记为final?。任何将最终类子类化的尝试都会报告为编译时错误。final?class