首页 > 其他 > 详细

第十五章.继承

时间:2015-03-23 14:46:21      阅读:232      评论:0      收藏:0      [点我收藏+]

来源

 

 

一个类可以继承另一个类的方法,属性和其它特性。当一个类继承其它类时,继承类叫子类,被继承类叫超类(或父类,super class)。在 Swift 中,继承是区分「类」与其它类型的一个基本特征。

在 Swift 中,类可以调用和访问超类的方法、属性和附属脚本,并且可以重写方法、属性和附属脚本来优化或修改它们的行为。

可以为类中继承来的属性添加属性观察器,这样一来,当属性值改变时,类就会被通知到。可以为任何属性添加属性观察器,无论它原本被定义为存储型属性还是计算型属性。

注意:

  1. Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个父类的话,这个类就自动成为基类。
  2. 在 Swift 中,初始化器默认是不继承的
  3. 子类只允许修改从父类继承来的变量属性,而不能修改继承来的常量属性。
  4. 一个类的实例方法会被这个类的所有子类继承。
  5. 不能为继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的。此外还要注意,不可以同时提供重写的 setter 和重写的属性观察器。因为已经为属性提供了定制的 setter,在 setter 中就可以观察到值的变化了。

 

基类(Base class)

下面的例子定义了一个叫Vehicle的基类。

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

构造器的最简单形式就像一个没有参数的实例方法,使用init关键字: 

init() { 
    // 执行构造过程 
} 

创建一个实例:

let someVehicle = Vehicle() 

 

子类

子类指的是在一个已有类的基础上创建一个新的类。子类继承父类的特性,并且可以优化或改变它。你还可以为子类添加新的特性。

为了指明某个类的超类,将超类名写在子类名的后面,用冒号分隔:

class SomeClass: SomeSuperclass { 
    // 类的定义 
} 

 

定义一个新的类叫Bicycle,它继承了Vehicle的特性:

class Bicycle: Vehicle { 
    init() { 
        super.init() 
        numberOfWheels = 2 
    } 
} 

 

调用它继承来的description方法,并且可以看到,它输出的属性值已经发生了变化:

let bicycle = Bicycle() 
println("Bicycle: \(bicycle.description())") 
// Bicycle: 2 wheels; up to 1 passengers 

子类还可以继续被其它类继承:

class Tandem: Bicycle { 
    init() { 
        super.init() 
        maxPassengers = 2 
    } 
} 

 

创建一个Tandem类的实例,打印它的描述,即可看到它的属性已被更新:

let tandem = Tandem() 
println("Tandem: \(tandem.description())") 
// Tandem: 2 wheels; up to 2 passengers 

 

重写(Overriding)

 

子类可以为继承来的实例方法、静态方法、实例属性,或附属脚本提供自己定制的实现。我们把这种行为叫重写(overriding)。

如果要重写某个特性,你需要在重写的定义前面加上 override 关键字。

 

访问父类的方法,属性及附属脚本

在合适的地方,你可以通过使用super前缀来访问父类版本的方法,属性或附属脚本:

通过super.someMethod()来调用父类的someMethod方法。

通过super.someProperty来调用父类的someProperty属性。

通过super[someIndex]来访问超类版本中的相同附属脚本。

 

重写方法

下面的例子定义了Vehicle的一个新的子类,叫Car,它重写了从Vehicle类继承来的description方法:

class Vehicle {
    var numberOfWheels: Int 
    var maxPassengers: Int 
    func description() -> String { 
        return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers" 
    }
    init() {
        numberOfWheels = 0 
        maxPassengers = 1 
    }
}
class Car: Vehicle { var speed: Double = 0.0 // 存储属性 init() { super.init() maxPassengers = 5 numberOfWheels = 4 } override func description() -> String { // 重写了父类的方法
    
return super.description() + "; " // 这里调用了super的description方法 + "traveling at \(speed) mph" } }
// 创建一个Car的新实例,并打印description方法的输出
let car = Car() println("Car: \(car.description())") // Car: 4 wheels; up to 5 passengers; traveling at 0.0 mph

 

重写属性

可以重写继承来的实例属性或类属性,提供自己定制的getter和setter,或添加属性观察器使重写的属性观察属性值什么时候发生改变。

 

重写属性的Getters和Setters
  1. 在重写一个属性时,必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
  2. 可以将一个继承来的只读属性重写为一个读写属性。但是,不能将一个继承来的读写属性重写为一个只读属性。
class Car: Vehicle {
    var speed: Double = 0.0 // 存储属性
    init() {
        super.init()
        maxPassengers = 5
        numberOfWheels = 4
    }
    override func description() -> String {  // 重写了父类的方法
     return super.description() + "; "   // 这里调用了super的description方法
            + "traveling at \(speed) mph"
    }
}

class SpeedLimitedCar: Car { 
    override var speed: Double  {   // 重写了父类的speed
      get {
          return super.speed     // 不想做修改,直接返回父类的speed
      }
      set {
          super.speed = min(newValue, 40.0) 
      }
    }
}

如果你尝试将SpeedLimitedCar实例的speed属性设置为一个大于40mph的数,然后打印description函数的输出,你会发现速度被限制在40mph:

let limitedCar = SpeedLimitedCar() 
limitedCar.speed = 60.0 
println("SpeedLimitedCar: \(limitedCar.description())") 
// SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph 

 

重写属性观察器(Property Observer)
class AutomaticCar: Car { 
    var gear = 1 
    override var speed: Double { // 重写了speed属性
    didSet { 
        gear = Int(speed / 10.0) + 1 
    } 
    } 
    override func description() -> String {   // 重写了description方法
        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 var
  • @final func
  • @final class func
  • @final subscript

你可以通过在关键字class前添加@final特性(@final class)来将整个类标记为 final 的,这样的类是不可被继承的,否则会报编译错误

 

2015-03-23

13:43:53

第十五章.继承

原文:http://www.cnblogs.com/huangzx/p/4359385.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!