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的方法、属性或类等,则报编译错误。












你可能感兴趣的:(继承,swift,重写)