Day11 继承

本页包含内容:
• 定义一个基类
• 子类生成
• 重写
• 防止重写

1、定义一个基类
不继承于其它类的类，称之为基类。

下面的例子定义了一个叫 Vehicle 的基类。这个基类声明了一个名为 currentSpeed ，默认值是 0.0 的存储属 性(属性类型推断为 Double )。
currentSpeed 属性的值被一个 String 类型的只读计算型属性 description 使用，用来创建车辆的描述。
Vehicle 基类也定义了一个名为 makeNoise 的方法。这个方法实际上不为 Vehicle 实例做任何事，但之后将会被 Vehicle 的子类定制:

<pre> class Vehicle {
//属性
var currentSpeed = 0.0
var description: String {
return "traveling at (currentSpeed) miles per hour"
}
//方法
func makeNoise() {
// 什么也不做-因为车辆不一定会有噪音
}
}

    //您可以用初始化语法创建一个 Vehicle 的新实例，即类名后面跟一个空括号:
    let someVehicle = Vehicle()
    
    //现在已经创建了一个 Vehicle 的新实例，你可以访问它的 description 属性来打印车辆的当前速度:
    someVehicle.currentSpeed = 120.0
    print("Vehicle:\(someVehicle.description)")</pre>

** 2、子类生成**

子类生成指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以进一步完善。你还可以为子类添加新的特性。
为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔:

下一个例子，定义一个叫 Bicycle 的子类，继承成父类 Vehicle :
<pre> class Bicycle: Vehicle {
var hasBasket = false
}
//访问自己的属性
let bicycle = Bicycle()
bicycle.hasBasket = true
//访问基类的属性
bicycle.currentSpeed = 15.0
print("Bicycle: (bicycle.description)")
// 打印 "Bicycle: traveling at 15.0 miles per hour"</pre>

** 3、重写**

子类可以为继承来的实例方法，类方法，实例属性，或下标提供自己定制的实现。我们把这种行为叫重写。
如果要重写某个特性，你需要在重写定义的前面加上 override关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少 override 关键字的重写都会在编译时被诊断为错误。

• 访问超类的方法，属性及下标

  在合适的地方，你可以通过使用 super 前缀来访问超类版本的方法，属性或下标:
  • 在方法 someMethod() 的重写实现中，可以通过 super.someMethod() 来调用超类版本的 someMethod() 方法。
  • 在属性 someProperty 的 getter 或 setter 的重写实现中，可以通过 super.someProperty 来访问超类版本的 someProperty 属性。
  • 在下标的重写实现中，可以通过 super[someIndex] 来访问超类版本中的相同下标

• 重写方法

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

    //下面的例子定义了 Vehicle 的一个新的子类，叫 Train ，它重写了从 Vehicle 类继承来的 makeNoise() 方法:
    class Train: Vehicle {
        override func makeNoise() {
            print("Choo Choo")
        }
    }
   // 如果你创建一个 Train 的新实例，并调用了它的 makeNoise() 方法，你就会发现 Train 版本的方法被调用:
    let train = Train()
    print(train.makeNoise)
    // 打印 "Choo Choo"

• 重写属性
  你可以重写继承来的实例属性或类型属性，提供定制的setter或getter，或添加属性观察器，可以观察属性什么时候发生改变

  • 重写属性的getter和setter
    你可以提供定制的 getter(或 setter)来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的 属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在 重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类 型的属性相匹配的。

你可以将一个继承来的只读属性重写为一个读写属性，只需要在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。

注意：
如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改 继承来的属性值，你可以直接通过 super.someProperty 来返回继承来的值，其中 someProperty 是你要重写的属性的名字。

以下的例子定义了一个新类，叫 Car ，它是 Vehicle 的子类。这个类引入了一个新的存储型属性叫做 gear ，默认值为整数 1 。 Car 类重写了继承自 Vehicle 的 description 属性，提供包含当前档位的自定义描述
<pre>class Car: Vehicle {
var gear = 1
override var description: String {
return super.description + " in gear (gear)"
}
}
// 重写的 description 属性首先要调用 super.description 返回 Vehicle 类的 description 属性。之后， Car 类版 本的 description 在末尾增加了一些额外的文本来提供关于当前档位的信息
let car = Car()
car.currentSpeed = 25.0
car.gear = 3
print("Car:(car.description)")</pre>

• • 重写属性观察器

你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被 通知到，无论那个属性原本是如何实现的

下面的例子定义了一个新类叫 AutomaticCar ，它是 Car 的子类。 AutomaticCar 表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位:

    class AutomaticCar: Car {
        override var currentSpeed: Double {
            didSet {
                gear = Int(currentSpeed / 10.0) + 1
            }
        }
    }
    //当你设置AutomaticCar的currentSpeed属性，属性的didSet 观察器就会自动设置gear属性，为新的速度选择一个合适的档位
    
    let automatic = AutomaticCar()
    automatic.currentSpeed = 35.0
    print("AutomaticCar: \(automatic.description)")
    // 打印 "AutomaticCar: traveling at 35.0 miles per hour in gear 4"

** 4、 防止重写**

     你可以通过把方法，属性或下标标记为 final 来防止它们被重写，只需要在声明关键字前加上 final 修饰符即可(例如: final var， final func， final class func，以及 )。
     如果你重写了带有  final 标记的方法，属性或下标，在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final 的。
     你可以通过在关键字 class 前添加 final 修饰符(final class)来将整个类标记为 final 的。这样的类是不可被继承的，试图继承这样的类会导致编译报错。