为有牺牲多壮志，敢教日月换新天。

Swift5.4 语言指南(十五) 继承

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9739308.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

一个类可以从另一个类继承方法，属性和其他特征。当一个类从另一个类继承时，继承的类称为子类，而其继承的类称为其超类。继承是一种基本行为，可将Swift中的类与其他类型区分开。

Swift中的类可以调用和访问属于其父类的方法，属性和下标，并可以提供这些方法，属性和下标的自己的重写版本以完善或修改其行为。Swift通过检查覆盖定义是否具有匹配的超类定义来帮助确保覆盖是正确的。

类还可以将属性观察器添加到继承的属性中，以便在属性值更改时得到通知。可以将属性观察器添加到任何属性，而不管它最初是被定义为存储属性还是计算属性。

定义基类

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

笔记

Swift类不从通用基类继承。您未指定超类而定义的类将自动成为基础类供您构建。

下面的示例定义了一个名为的基类Vehicle。该基类定义了一个名为的存储属性currentSpeed，其默认值为0.0（推断属性类型为Double）。该currentSpeed属性的值由String调用的只读计算属性使用，description以创建车辆的描述。

所述Vehicle基类还定义了一个称为方法makeNoise。此方法实际上不会对基本Vehicle实例做任何事情，但是稍后将由其子类自定义Vehicle：

  1. class Vehicle {
  2. var currentSpeed = 0.0
  3. var description: String {
  4. return "traveling at \(currentSpeed) miles per hour"
  5. }
  6. func makeNoise() {
  7. // do nothing - an arbitrary vehicle doesn't necessarily make a noise
  8. }
  9. }

您可以Vehicle使用Initializer语法创建一个新的实例，该实例以类型名称和空括号的形式编写：

  1. let someVehicle = Vehicle()

创建新Vehicle实例后，您可以访问其description属性以打印出人类对车辆当前速度的描述：

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

在Vehicle类定义的共同特点为任意车辆，但没有太大用处本身。为了使其更有用，您需要对其进行优化以描述更多特定类型的车辆。

子类化

子类化是在现有类的基础上建立新类的行为。子类继承现有类的特征，然后可以对其进行优化。您还可以向子类添加新的特征。

要表明子类具有超类，请在超类名称之前写上子类名称，并用冒号分隔：

  1. class SomeSubclass: SomeSuperclass {
  2. // subclass definition goes here
  3. }

以下示例定义了一个名为的子类Bicycle，其超类为Vehicle：

  1. class Bicycle: Vehicle {
  2. var hasBasket = false
  3. }

新Bicycle类自动获得的所有特征Vehicle，例如currentSpeed和description属性以及makeNoise()方法。

除了继承的特性外，Bicycle该类还定义了一个新的存储属性，hasBasket其默认值为false（推断Bool该属性的类型）。

默认情况下，Bicycle您创建的任何新实例都不会包含篮子。您可以设置hasBasket属性true为特定Bicycle的创建实例之后，例如：

  1. let bicycle = Bicycle()
  2. bicycle.hasBasket = true

您还可以修改继承的currentSpeed一个财产Bicycle实例，查询实例的继承description财产：

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

子类本身可以被子类化。下一个示例Bicycle为两人座自行车创建一个子类，称为“双人”：

  1. class Tandem: Bicycle {
  2. var currentNumberOfPassengers = 0
  3. }

Tandem从中继承所有属性和方法Bicycle，而从中继承所有属性和方法Vehicle。该Tandem子类还增加了一个新的存储属性调用currentNumberOfPassengers，用的默认值0。

如果创建的实例Tandem，则可以使用其任何新属性和继承的属性，并查询description其继承自的只读属性Vehicle：

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

覆写

子类可以提供其自己的实例方法，类型方法，实例属性，类型属性或下标的自定义实现，否则该实例方法将从超类继承。这称为覆盖。

要覆盖原本会被继承的特征，请在覆盖的定义前面加上override关键字。这样做可以澄清您打算提供替代，并且没有错误地提供匹配的定义。意外覆盖可能会导致意外行为，并且override在编译代码时，任何没有关键字的覆盖都会被诊断为错误。

该override关键字还提示斯威夫特编译器检查您的覆盖类的超（或父母中的一方）有符合您的覆盖提供的一个声明。此检查可确保您的覆盖定义正确。

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

当为子类提供方法，属性或下标替代时，将现有的超类实现用作替代的一部分有时会很有用。例如，您可以优化该现有实现的行为，或者将修改后的值存储在现有的继承变量中。

在适当的情况下，您可以使用super前缀访问方法，属性或下标的超类版本：

  • 名为的重写方法someMethod()可以someMethod()通过super.someMethod()在重写方法实现中调用来调用的超类版本。
  • 被称为覆盖的属性someProperty可以访问的超类版本someProperty作为super.someProperty压倒一切的getter或setter实现中。
  • 的覆盖下标someIndex可以从覆盖下标实现中访问同一下标的超类版本super[someIndex]。

覆盖方法

您可以重写继承的实例或类型方法，以在子类中提供该方法的定制或替代实现。

以下示例定义了一个Vehicle名为的新子类Train，该子类将覆盖从其继承的makeNoise()方法：TrainVehicle

  1. class Train: Vehicle {
  2. override func makeNoise() {
  3. print("Choo Choo")
  4. }
  5. }

如果创建的新实例Train并调用其makeNoise()方法，则可以看到该方法的Train子类版本被调用：

  1. let train = Train()
  2. train.makeNoise()
  3. // Prints "Choo Choo"

覆盖属性

您可以覆盖继承的实例或类型属性，以为该属性提供自己的自定义getter和setter，或添加属性观察器以使覆盖的属性能够在基础属性值更改时进行观察。

覆盖属性获取器和设置器

您可以提供一个自定义的getter（如果合适的话，可以使用setter）来覆盖任何继承的属性，而不管该继承的属性是在源上实现为存储属性还是计算属性。子类不知道继承属性的存储或计算性质，它仅知道继承属性具有特定的名称和类型。您必须始终声明要覆盖的属性的名称和类型，以使编译器能够检查您的覆盖是否与具有相同名称和类型的超类属性匹配。

通过在子类属性重写中同时提供getter和setter，可以将继承的只读属性呈现为读写属性。但是，您不能将继承的读写属性表示为只读属性。

笔记

如果在属性替代中提供了一个setter，则还必须为该替代提供一个getter。如果您不想在覆盖的getter中修改继承的属性的值，则可以简单地通过super.someProperty从getter返回值来传递继承的值，其中someProperty您要覆盖的属性的名称是。

以下示例定义了一个名为的新类Car，它是的子类Vehicle。该Car课程介绍了新的存储属性调用gear，用默认整数值1。的Car类也覆盖了description它从继承属性Vehicle，以提供包括当前齿轮定制描述：

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

description通过调用super.description，开始属性的重写，该方法返回Vehicle类的description属性。然后，Car该类的版本description在此描述的末尾添加一些额外的文本，以提供有关当前装备的信息。

如果创建Car该类的实例并设置其gear和currentSpeed属性，则可以看到其description属性返回在Car类中定义的定制描述：

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

覆盖属性观察者

您可以使用属性覆盖将属性观察器添加到继承的属性。这使您可以在继承的属性的值更改时得到通知，而无论该属性最初是如何实现的。有关属性观察者的更多信息，请参见属性观察者。

笔记

您不能将属性观察器添加到继承的常量存储属性或继承的只读计算属性。这些属性的值无法设置，因此不建议将willSet或didSet实现作为替代的一部分提供。

还要注意，您不能同时为同一属性提供覆盖的设置器和覆盖的属性观察器。如果您想观察属性值的变化，并且已经在为该属性提供自定义设置器，则可以简单地观察自定义设置器中的任何值更改。

以下示例定义了一个名为的新类AutomaticCar，它是的子类Car。所述AutomaticCar类表示用自动变速器，自动选择适当的齿轮基于当前速度使用一辆车：

  1. class AutomaticCar: Car {
  2. override var currentSpeed: Double {
  3. didSet {
  4. gear = Int(currentSpeed / 10.0) + 1
  5. }
  6. }
  7. }

当你设置currentSpeed一个的属性AutomaticCar实例属性的didSet观察者设置实例的gear属性齿轮的新速度一个合适的选择。具体来说，属性观察者选择的齿轮是新currentSpeed值除以10，并四舍五入为最接近的整数plus 1。的速度35.0产生一个齿轮4：

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

防止超越

您可以通过将方法，属性或下标标记为final来防止其被覆盖。通过写做到这一点final的方法，属性，或标的介绍人关键字之前修饰符（如，，，和）。final varfinal funcfinal class funcfinal subscript

尝试覆盖子类中的最终方法，属性或下标的任何尝试都将报告为编译时错误。您在扩展的类中添加的方法，属性或下标也可以在扩展的定义内标记为final。

您可以通过在类定义（）中final的class关键字之前编写修饰符来将整个类标记为最终类。任何试图将最终类作为子类的尝试都将报告为编译时错误。final class

posted @ 2018-10-03 10:31  为敢技术  阅读(253)  评论(0)  编辑  收藏  举报