swift(13)继承

类继承的语法与C很相似，也是在子类后面添加冒号和父类名：

//基类
class Vehicle {
    var numberOfWheels: Int
    var maxPassengers: Int
    func description() -> String {
        return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers"
    }
    init() {
        numberOfWheels = 0
        maxPassengers = 1
    }
}

//子类
class Bicycle: Vehicle {
    init() {
        super.init()
        numberOfWheels = 2
    }
}
let bicycle = Bicycle()
println("Bicycle: \(bicycle.description())")
//子类继承父类的描述方法，打印 Bicycle: 2 wheels; up to 1 passengers

子类的构造方法，可以重新初始化继承自父类的变量，但是要注意，只能修改var型的变量，不能修改let型的常量

class Tandem: Bicycle {
    init() {
        super.init()
        maxPassengers = 2
    }
}
let tandem = Tandem()
println("Tandem: \(tandem.description())")
// Tandem: 2 wheels; up to 2 passengers

继承就是拿来直接使用，下面是重写，与C不同，重写要求在前面加override关键字，防止笔误产生，即添加了override关键字，则编译器会检查该函数及其参数是否与父类相同，如果不同，则会报告编译错误。

方法重写：

class Car: Vehicle {
    var speed: Double = 0.0
    init() {
        super.init()
        maxPassengers = 5
        numberOfWheels = 4
    }
    override func description() -> String {
        return super.description() + "; " + "traveling at \(speed) mph"
    }
}

let car = Car()
println("Car: \(car.description())")
// Car: 4 wheels; up to 5 passengers; traveling at 0.0 mph

重写则表示方法名，属性名等与父类完全相同，此时如果想调用父类的该方法或属性，则在前面冠以super区分，下标则用super[someIndex]

属性重写，可以重写属性的getter，setter方法。需要注意如下几点：

1、可以将只读的属性（只有getter方法）重写为读写的属性，即添加setter方法

2、不能将读写的属性重写为只读的属性。

3、如果重写了setter方法，则也必须重写getter方法，即使仅在重写的getter方法里返回super.someProperty。

4、不能给常量存储属性和只读计算属性添加监视方法。

5、不能同时重写setter和监视方法。

重写属性的getter和setter：

class SpeedLimitedCar: Car {
    override var speed: Double  {
    get {
        return super.speed
    }
    set {
        super.speed = min(newValue, 40.0)
    }
    }
}
let limitedCar = SpeedLimitedCar()
limitedCar.speed = 60.0
println("SpeedLimitedCar: \(limitedCar.description())")
// SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph

重写属性的监视方法

class AutomaticCar: Car {
    var gear = 1
    override var speed: Double {
    didSet {
        gear = Int(speed / 10.0) + 1
    }
    }
    override func description() -> String {
        return super.description() + " in gear \(gear)"
    }
}
let automatic = AutomaticCar()
automatic.speed = 35.0
println("AutomaticCar: \(automatic.description())")
// AutomaticCar: 4 wheels; up to 5 passengers; traveling at 35.0 mph in gear 4

如果想防止属性，方法，下标被重写，可在声明的最前面添加@final关键字

如果不希望一个类被继承，可以在类的前面冠以@final关键字。

如下：

@final var someProperty
@final func someFunction  
@final class func staticFunction
@final subscript(someIndex:Int) -> String {}

@final class someClass
{}

如果出现继承带有关键字@final的方法、属性或类等，则报编译错误。