Swift2.1-继承

继承

一个类可以从另一个类继承方法，属性和其他的特性。当一个类从另一个类继承的时候，继承类被称为子类，这个类继承的类被称为父类。在Swift中，继承是基本的，从Swift中的其他类型来区分类的一种行为。

在Swift中类可以调用和访问方法，属性和属于它们父类的下标脚本，并且提供它们自己重写的方法，属性和下标脚本来定义或修改它们的行为。Swift会确保你的重写是正确的，通过检查，重写定义都有一个与之匹配的父类定义。

类也可以向继承的属性添加属性监听者，当属性的值改变了以便通知。可以添加任何属性到属性监听者中，不管它是被定义为存储或是计算属性。

定义基类

任何不从另一个类继承的类都称为基类。

注意:

Swift类不从一个通用基类继承。你定义的类不会自动地指定一个父类，你定义了没有指定父类的类，在你创建时会自动成为基类。

下面的例子定义了一个叫做

Vehicle

的基类。这个基类定义了一个存储属性称为

currentSpeed

，它有一个默认值0。0(推断为一个

Double

类型的属性)。

currentSpeed

属性的值被用在一个称为

description

的

String

类型的只读计算属性来创建一个vehicle的描述。

Vehicle

基类也定义了一个称为

makeNoise

的方法。这个方法实际上不会为这个基类的实例做任何事，但是后面它可以被

Vehicle

的子类自定义:

class Vehicle {
var currentSpeed = 0.0
var description: String {
return "traveling at \(currentSpeed) miles per hour"
}
func makeNoise() {
// do nothing - an arbitrary vehicle doesn't necessarily make a noise
}
}

你使用初始化语法创建了一个新的

Vehicle

实例，写为类型名后面跟着一个空括号:

let someVehicle = Vehicle()

创建了一个新的

Vehicle

实例之后，你可以访问它的

description

属性来输出一个人类可读的，

vehicle

的当前速度的描述:

print("Vehicle: \(someVehicle。description)")
// Vehicle: traveling at 0.0 miles per hour

Vehicle

类为任意的车辆定义了共同的特点，但是对它本身没有太大用处。为了让它更有用，你需要重定义它来描述更具体的车辆种类。

子类化

子类化是基于现有类的新类的行为。子类从现有的类继承了一些特性，你可以重新定义它们。你也可以为子类添加新的特性。

为了表示子类有父类，要把子类写在父类的前面，用冒号隔开:

class SomeSubclass: SomeSuperclass {
// subclass definition goes here
}

下面的例子定义了一个称为

Bicycle

的子类，继承于

Vehicle

:

class Bicycle: Vehicle {
var hasBasket = false
}

新的

Bicycle

类获得了

Vehicle

的所有特性，例如它的

currentSpeed

和

description

属性和

makeNoise()

方法。

除了继承的特点，

Bicycle

类定义了一个新的存储属性

hasBasket

，并且默认值为

false

(推断它的类型为

Bool

)。

默认情况，任何你新建的

Bicycle

实例都都不会有篮子。在一个特定的

Bicycle

类实例创建之后，你可以为这个实例设置

hasBasket

属性为

true

:

let bicycle = Bicycle()
bicycle.hasBasket = true

你也可以在

Bicycle

类实例中修改继承的

currentSpeed

属性，或是查询实例的继承

description

属性:

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

子类也可以被继承。下个例子创建了一个

Bicycle

类的子类，一个两座的自行车称为”tandem”:

class Tandem: Bicycle {
var currentNumberOfPassengers = 0
}

Tandem

从

Bicycle

继承了所有的属性和方法，也依次从

Vehicle

继承了所有属性和方法。

Tandem

子类也添加了一个新的称为

currentNumberOfPassengers

的存储属性，并且有一个默认值0:

let tandem = Tandem()
tandem.hasBasket = true
tandem.currentNumberOfPassengers = 2
tandem.currentSpeed = 22.0
print("Tandem: \(tandem.description)")
// Tandem: traveling at 22.0 miles per hour

重写

一个子类可以提供它自己的实例方法，类型方法，实例属性，类型属性或下标脚本的自定义实现，否则，它将会从父类继承。这就是重写。

为了重写一个被继承的特性，你要在你的重写定义前面加上

override

关键词。这样做说明你打算提供一个重写，如果不这样做就会匹配一个错误的定义。意外的重写可能导致意意想不到的行为，并且当你编译的时候，对于任意没有

override

关键词的重写都会被视为错误。

override

关键词也提供Swift编译器检查，你的重写类的父类(或者父类的父类)有一个声明来匹配你提供的重写。检查确保你重写的定义是是正确的。

访问父类方法，属性和下标脚本

当你为子类提供了一个方法，属性或者下标脚本，有时那是有用的，来使用现有的父类实现作为你重写的一部分。例如，你可以重定义现有实现的行为，或者在现有的继承变量中存储一个修正值。

这是适当的，你可以通过使用

super

前缀，访问父类的方法，属性或下标脚本:

一个命名为

someMethod()

的重写方法可以通过

super。someMethod()

在重写的方法实现中，调用父类的

someMethod()

方法。

一个命名为

someProperty

的重写属性当通过

super。someProperty

在重写的getter或setter实现中，可以访问父类的

someProperty

属性。

一个命名为

someIndex

的重写下标脚本当使用

super[someIndex]

在重写的下标脚本实现中，可以访问父类中相同的脚本。

重写方法

你可以在你的子类中，重写一个继承的实例或类型方法来提供定制的或是可选的方法实现。

下面的例子定义了一个新的

Vehicle

子类，称为

Train

，重写了

makeNoise()

方法:

class Train: Vehicle {
override func makeNoise() {
print("Choo Choo")
}
}

如果你创建了一个新的Train实例，并且调用了

makeNoise()

方法，你可以看到

Train

子类的方法被调用了:

let train = Train()
train.makeNoise()
// prints "Choo Choo"

重写属性

你可以提供一个继承实例或类型来为你自己的属性提供你自己自定义的getter和setter，或者添加属性监听者确保当底层属性值改变时来监听重写的属性。

重写属性getter和setter

你可以提供一个自定义的getter(和setter，如果合适的话)来重写任意的继承属性，不管在开始时继承属性是否实现了存储属性或计算属性。一个继承属性的存储或计算性质不被看做一个子类–它仅被看做继承属性有某个名字或类型。你必须声明你重写的属性名字和类型，来确保编译器可以检查你的重写匹配了父类中有相同名字和类型的属性。

通过在你的子类重写属性里提供getter和setter方法，你可以把一个继承为只读的属性重写为读写的属性。然而，你不能把继承为读写的属性重写为只读属性。

注意:

如果你提供了一个setter作为一个属性重写的部分，你也必须为重写提供一个getter。如果你不想在重写getter时修改继承属性的值，那么你可以简单通过从getter返回

super。someProperty

继承的值，

someProperty

就是你重写的属性的名字。

下面的例子定义了一个新类

Car

，继承自

Vehicle

类。

Car

类介绍了一个新的存储属性

gear

，并且有一个默认的整型值 1。

Car

类也重写了

description

属性，它继承自

Vehicle

，提供了一个自定义的描述，介绍了当前的gear:

class Car: Vehicle {
var gear = 1
override var description: String {
return super.description + " in gear \(gear)"
}
}

重写的

description

属性通过调用

super。description

开始，返回了

Vehicle

类的

description

属性。

Car

类的

description

之后就添加了一些额外的文本到描述的末尾，提供了关于当前的gear信息。

如果你创建一个

Car

类的实例，并且设置了它的

setter

和

currentSpeed

属性，你可以看到它的

description

属性在

Car

类的定义里返回了定制的描述:

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

重写属性监听者

你可以使用属性重写来添加属性监听者为继承的属性。这就可以当继承的属性值改变的时候通知你，不管这个属性最初是如何实现的。对于属性监听者上更多的信息，可以看属性监听者。

注意:

你不能添加属性监听者来继承常量的存储属性或者继承只读的计算属性。这些属性的值不能被set

(设置)，所以提供

willSet

或

didSet

实现作为重写的一部分是不恰当的。

也要注意，你不能为相同的属性提供一个重写的setter和一个重写的属性监听者。如果你想要监听属性值的改变，并且你已经为那个属性提供了一个自定义的setter，那么你可以从自定义的setter里简单地监听任意值的改变。

下面的例子定义了一个新类

AutomaticCar

，继承自

Car

。

AutomaticCar

类代表一辆车有一个自动的变速箱(gearbox)，可以根据当前的速度自动地选择一个合适的gear:

class AutomaticCar : Car {
override var currentSpeed: Double {
didSet {
gear = Int(currentSpeed / 10.0) + 1
}
}
}

无论你在什么时候设置了

AutomaticCar

实例的

currentSpeed

属性，这个属性的

didSet

监听者都会设置实例的gear属性给新的速度一个合适的值。具体地说，属性监听者选择了一个gear，它是新的

currentSpeed

值除以10，四舍五入到最近整数，然后加1。例如，速度是35，那么gear就是4:

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

阻止重写

你可以通过标记为

final

来阻止一个方法，属性或者下标脚本被重写。通过在方法，属性或者下标脚本的关键字前写

final

修饰符(例如，

final var

，

final func

，

final class func

，

fianl subscript

)。

任何想要在子类里重写

final

方法，属性或下标脚本都会报一个编译时错误。在扩展中添加到一个类中的方法，属性或下标脚本也可以子扩展的定义里被标记为

final

。

你可以标记一个额外的类通过在

class

关键字前面写

final

修饰符为

final

(

final class

)。任何想要子类为一个

final

类都会报一个编译时错误。