下面的例子定義了一個叫Vehicle的基類。這個基類聲明了一個名為currentSpeed，默認值是0.0的存儲屬性(屬性類型推斷為Double)。currentSpeed屬性的值被一個String 類型的只讀計算型屬性description使用，用來創(chuàng)建車輛的描述。

Vehicle基類也定義了一個名為makeNoise的方法。這個方法實際上不為Vehicle實例做任何事，但之后將會被Vehicle的子類定制

    class Vehicle {
        var currentSpeed = 0.0
        var description: String {
            return "traveling at \(currentSpeed) miles per hour"
        }
        func makeNoise() {
            // 什么也不做-因為車輛不一定會有噪音
        }
    }

您可以用初始化語法創(chuàng)建一個Vehicle的新實例，即 TypeName后面跟一個空括號：

    let someVehicle = Vehicle()

現(xiàn)在已經創(chuàng)建了一個Vehicle的新實例，你可以訪問它的description屬性來打印車輛的當前速度。

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

子類生成（Subclassing）

子類生成（Subclassing）指的是在一個已有類的基礎上創(chuàng)建一個新的類。子類繼承超類的特性，并且可以優(yōu)化或改變它。你還可以為子類添加新的特性。

為了指明某個類的超類，將超類名寫在子類名的后面，用冒號分隔：

    class SomeClass: SomeSuperclass {
        // 類的定義
    }

下一個例子，定義一個更具體的車輛類叫Bicycle。這個新類是在 Vehicle類的基礎上創(chuàng)建起來。因此你需要將Vehicle類放在 Bicycle類后面，用冒號分隔。

我們可以將這讀作：

“定義一個新的類叫Bicycle，它繼承了Vehicle的特性”；

    class Bicycle: Vehicle {
        var hasBasket = false
    }

新的Bicycle類自動獲得Vehicle類的所有特性，比如 currentSpeed和description屬性，還有它的makeNoise方法。

除了它所繼承的特性，Bicycle類還定義了一個默認值為false的存儲型屬性hasBasket（屬性推斷為Bool）。

默認情況下，你創(chuàng)建任何新的Bicycle實例將不會有一個籃子，創(chuàng)建該實例之后，你可以為特定的Bicycle實例設置hasBasket屬性為ture：

    let bicycle = Bicycle()
    bicycle.hasBasket = true

你還可以修改Bicycle實例所繼承的currentSpeed屬性，和查詢實例所繼承的description屬性：

    bicycle.currentSpeed = 15.0
    println("Bicycle: \(bicycle.description)")
    // Bicycle: traveling at 15.0 miles per hour

子類還可以繼續(xù)被其它類繼承，下面的示例為Bicycle創(chuàng)建了一個名為Tandem（雙人自行車）的子類：

    class Tandem: Bicycle {
        var currentNumberOfPassengers = 0
    }

Tandem從Bicycle繼承了所有的屬性與方法，這又使它同時繼承了Vehicle的所有屬性與方法。Tandem也增加了一個新的叫做currentNumberOfPassengers的存儲型屬性，默認值為0。

如果你創(chuàng)建了一個Tandem的實例，你可以使用它所有的新屬性和繼承的屬性，還能查詢從Vehicle繼承來的只讀屬性description：

    let tandem = Tandem()
    tandem.hasBasket = true
    tandem.currentNumberOfPassengers = 2
    tandem.currentSpeed = 22.0
    println("Tandem: \(tandem.description)")
    // Tandem: traveling at 22.0 miles per hour

重寫（Overriding）

子類可以為繼承來的實例方法（instance method），類方法（class method），實例屬性（instance property），或下標腳本（subscript）提供自己定制的實現(xiàn)（implementation）。我們把這種行為叫重寫（overriding）。

如果要重寫某個特性，你需要在重寫定義的前面加上override關鍵字。這么做，你就表明了你是想提供一個重寫版本，而非錯誤地提供了一個相同的定義。意外的重寫行為可能會導致不可預知的錯誤，任何缺少override關鍵字的重寫都會在編譯時被診斷為錯誤。

override關鍵字會提醒 Swift 編譯器去檢查該類的超類（或其中一個父類）是否有匹配重寫版本的聲明。這個檢查可以確保你的重寫定義是正確的。

訪問超類的方法，屬性及下標腳本

當你在子類中重寫超類的方法，屬性或下標腳本時，有時在你的重寫版本中使用已經存在的超類實現(xiàn)會大有裨益。比如，你可以優(yōu)化已有實現(xiàn)的行為，或在一個繼承來的變量中存儲一個修改過的值。

在合適的地方，你可以通過使用super前綴來訪問超類版本的方法，屬性或下標腳本：

在方法someMethod的重寫實現(xiàn)中，可以通過super.someMethod()來調用超類版本的someMethod方法。
在屬性someProperty的 getter 或 setter 的重寫實現(xiàn)中，可以通過super.someProperty來訪問超類版本的someProperty屬性。
在下標腳本的重寫實現(xiàn)中，可以通過super[someIndex]來訪問超類版本中的相同下標腳本。

重寫方法

在子類中，你可以重寫繼承來的實例方法或類方法，提供一個定制或替代的方法實現(xiàn)。

下面的例子定義了Vehicle的一個新的子類，叫Train，它重寫了從Vehicle類繼承來的makeNoise方法：

    class Train: Vehicle {
        override func makeNoise() {
            println("Choo Choo")
        }
    }

如果你創(chuàng)建一個Train的新實例，并調用了它的makeNoise方法，你就會發(fā)現(xiàn)Train版本的方法被調用：

    let train = Train()
    train.makeNoise()
    // prints "Choo Choo"

重寫屬性

你可以重寫繼承來的實例屬性或類屬性，提供自己定制的getter和setter，或添加屬性觀察器使重寫的屬性觀察屬性值什么時候發(fā)生改變。

重寫屬性的Getters和Setters

你可以提供定制的 getter（或 setter）來重寫任意繼承來的屬性，無論繼承來的屬性是存儲型的還是計算型的屬性。子類并不知道繼承來的屬性是存儲型的還是計算型的，它只知道繼承來的屬性會有一個名字和類型。你在重寫一個屬性時，必需將它的名字和類型都寫出來。這樣才能使編譯器去檢查你重寫的屬性是與超類中同名同類型的屬性相匹配的。

你可以將一個繼承來的只讀屬性重寫為一個讀寫屬性，只需要你在重寫版本的屬性里提供 getter 和 setter 即可。但是，你不可以將一個繼承來的讀寫屬性重寫為一個只讀屬性。

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

以下的例子定義了一個新類，叫Car，它是Vehicle的子類。這個類引入了一個新的存儲型屬性叫做gear，默認為整數1。Car類重寫了繼承自Vehicle的description屬性，提供自定義的，包含當前檔位的描述：

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

重寫的description屬性，首先要調用super.description返回Vehicle類的description屬性。之后，Car類版本的description在末尾增加了一些額外的文本來提供關于當前檔位的信息。

如果你創(chuàng)建了Car的實例并且設置了它的gear和currentSpeed屬性，你可以看到它的description返回了Car中定義的description：

    let car = Car()
    car.currentSpeed = 25.0
    car.gear = 3
    println("Car: \(car.description)")
    // Car: traveling at 25.0 miles per hour in gear 3

重寫屬性觀察器（Property Observer）

你可以在屬性重寫中為一個繼承來的屬性添加屬性觀察器。這樣一來，當繼承來的屬性值發(fā)生改變時，你就會被通知到，無論那個屬性原本是如何實現(xiàn)的。關于屬性觀察器的更多內容，請看屬性觀察器。

注意：
你不可以為繼承來的常量存儲型屬性或繼承來的只讀計算型屬性添加屬性觀察器。這些屬性的值是不可以被設置的，所以，為它們提供willSet或didSet實現(xiàn)是不恰當。此外還要注意，你不可以同時提供重寫的 setter 和重寫的屬性觀察器。如果你想觀察屬性值的變化，并且你已經為那個屬性提供了定制的 setter，那么你在 setter 中就可以觀察到任何值變化了。

下面的例子定義了一個新類叫AutomaticCar，它是Car的子類。AutomaticCar表示自動擋汽車，它可以根據當前的速度自動選擇合適的擋位:

    class AutomaticCar: Car {
        override var currentSpeed: Double {
            didSet {
                gear = Int(currentSpeed / 10.0) + 1
            }
        }
    }

當你設置AutomaticCar的currentSpeed屬性，屬性的didSet觀察器就會自動地設置gear屬性，為新的速度選擇一個合適的擋位。具體來說就是，屬性觀察器將新的速度值除以10，然后向下取得最接近的整數值，最后加1來得到檔位gear的值。例如，速度為10.0時，擋位為1；速度為35.0時，擋位為4：

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

防止重寫

你可以通過把方法，屬性或下標腳本標記為final來防止它們被重寫，只需要在聲明關鍵字前加上@final特性即可。（例如：final var, final func, final class func, 以及 final subscript）

如果你重寫了final方法，屬性或下標腳本，在編譯時會報錯。在擴展中，你添加到類里的方法，屬性或下標腳本也可以在擴展的定義里標記為 final。

你可以通過在關鍵字class前添加final特性（final class）來將整個類標記為 final 的，這樣的類是不可被繼承的，否則會報編譯錯誤。

上一篇：函數（Functions）下一篇：Optional Chaining

繼承（Inheritance）

定義一個基類（Base class）