構造過程
構造過程是使用類、結構體或枚舉類型的實例之前的準備過程。在新實例可用前必須執行這個過程，具體操作包括設置實例中每個存儲型屬性的初始值和執行其他必須的設置或初始化工作。
通過定義構造器（Initializers）來實現構造過程，這些構造器可以看做是用來創建特定類型新實例的特殊方法。與 Objective-C 中的構造器不同，Swift 的構造器無需返回值，它們的主要任務是保證新實例在第一次使用前完成正確的初始化。
存儲屬性的初始賦值
類和結構體在創建實例時，必須為所有存儲型屬性設置合適的初始值。存儲型屬性的值不能處于一個未知的狀態。
你可以在構造器中為存儲型屬性賦初值，也可以在定義屬性時為其設置默認值。
注意
當你為存儲型屬性設置默認值或者在構造器中為其賦值時，它們的值是被直接設置的，不會觸發任何屬性觀察者（
property observers）。
構造器
構造器在創建某個特定類型的新實例時被調用。它的最簡形式類似于一個不帶任何參數的實例方法，以關鍵字init命名：
init() {
// 在此處執行構造過程
}
例子：
struct Fahrenheit {
var temperature: Double
init() {
temperature = 32.0
}
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
// 輸出 "The default temperature is 32.0° Fahrenheit”
默認屬性值
如前所述，你可以在構造器中為存儲型屬性設置初始值。同樣，你也可以在屬性聲明時為其設置默認值。
注意
如果一個屬性總是使用相同的初始值，那么為其設置一個默認值比每次都在構造器中賦值要好。兩種方法的效果是一樣的，只不過使用默認值讓屬性的初始化和聲明結合得更緊密。使用默認值能讓你的構造器更簡潔、更清晰，且能通過默認值自動推導出屬性的類型；同時，它也能讓你充分利用默認構造器、構造器繼承等特性（后續章節將講到）。
你可以使用更簡單的方式在定義結構體Fahrenheit時為屬性temperature設置默認值：
struct Fahrenheit {
var temperature = 32.0
}
構造參數
自定義構造過程時，可以在定義中提供構造參數，指定所需值的類型和名字。構造參數的功能和語法跟函數和方法的參數相同。
struct Fahrenheit {
var temperature: Double
init(temperature:Double) {
self.temperature = temperature
}
}
可選屬性類型
如果你定制的類型包含一個邏輯上允許取值為空的存儲型屬性——無論是因為它無法在初始化時賦值，還是因為它在之后某個時間點可以賦值為空——你都需要將它定義為可選類型（optional type）。可選類型的屬性將自動初始化為nil，表示這個屬性是有意在初始化時設置為空的。
構造過程中常量屬性的修改
你可以在構造過程中的任意時間點給常量屬性指定一個值，只要在構造過程結束時是一個確定的值。一旦常量屬性被賦值，它將永遠不可更改。
注意
對于類的實例來說，它的常量屬性只能在定義它的類的構造過程中修改；不能在子類中修改。
你可以修改上面的SurveyQuestion示例，用常量屬性替代變量屬性text，表示問題內容text在SurveyQuestion的實例被創建之后不會再被修改。盡管text屬性現在是常量，我們仍然可以在類的構造器中設置它的值：
class SurveyQuestion {
let text: String
var response: String?
init(text: String) {
self.text = text
}
func ask() {
print(text)
}
}
let beetsQuestion = SurveyQuestion(text: "How about beets?")
beetsQuestion.ask()
// 輸出 "How about beets?"
默認構造器
如果結構體或類的所有屬性都有默認值，同時沒有自定義的構造器，那么 Swift 會給這些結構體或類提供一個默認構造器（default initializers）。這個默認構造器將簡單地創建一個所有屬性值都設置為默認值的實例。
下面例子中創建了一個類ShoppingListItem，它封裝了購物清單中的某一物品的屬性：名字（name）、數量（quantity）和購買狀態 purchase state：
class ShoppingListItem {
var name: String?
var quantity = 1
var purchased = false
}
var item = ShoppingListItem()
結構體的逐一成員構造器
除了上面提到的默認構造器，如果結構體沒有提供自定義的構造器，它們將自動獲得一個逐一成員構造器，即使結構體的存儲型屬性沒有默認值。
逐一成員構造器是用來初始化結構體新實例里成員屬性的快捷方法。我們在調用逐一成員構造器時，通過與成員屬性名相同的參數名進行傳值來完成對成員屬性的初始賦值。
struct Size {
var width = 0.0, height = 0.0
}
let twoByTwo = Size(width: 2.0, height: 2.0)
值類型的構造器代理
構造器可以通過調用其它構造器來完成實例的部分構造過程。這一過程稱為構造器代理，它能減少多個構造器間的代碼重復。
構造器代理的實現規則和形式在值類型和類類型中有所不同。值類型（結構體和枚舉類型）不支持繼承，所以構造器代理的過程相對簡單，因為它們只能代理給自己的其它構造器。類則不同，它可以繼承自其它類，這意味著類有責任保證其所有繼承的存儲型屬性在構造時也能正確的初始化。
對于值類型，你可以使用self.init在自定義的構造器中引用相同類型中的其它構造器。并且你只能在構造器內部調用self.init。
如果你為某個值類型定義了一個自定義的構造器，你將無法訪問到默認構造器（如果是結構體，還將無法訪問逐一成員構造器）。這種限制可以防止你為值類型增加了一個額外的且十分復雜的構造器之后,仍然有人錯誤的使用自動生成的構造器
注意
假如你希望默認構造器、逐一成員構造器以及你自己的自定義構造器都能用來創建實例，可以將自定義的構造器寫到擴展（extension）中，而不是寫在值類型的原始定義中。
struct Rect {
var origin = Point()
var size = Size()
init() {}
init(origin: Point, size: Size) {
self.origin = origin
self.size = size
}
init(center: Point, size: Size) {
let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}
指定構造器和便利構造器
指定構造器（designated initializers）是類中最主要的構造器。一個指定構造器將初始化類中提供的所有屬性，并根據父類鏈往上調用父類的構造器來實現父類的初始化。
每一個類都必須擁有至少一個指定構造器。在某些情況下，許多類通過繼承了父類中的指定構造器而滿足了這個條件。
便利構造器（convenience initializers）是類中比較次要的、輔助型的構造器。你可以定義便利構造器來調用同一個類中的指定構造器，并為其參數提供默認值。你也可以定義便利構造器來創建一個特殊用途或特定輸入值的實例。
你應當只在必要的時候為類提供便利構造器，比方說某種情況下通過使用便利構造器來快捷調用某個指定構造器，能夠節省更多開發時間并讓類的構造過程更清晰明了。
指定構造器和便利構造器的語法
類的指定構造器的寫法跟值類型簡單構造器一樣：
init(parameters) {
statements
}
便利構造器也采用相同樣式的寫法，但需要在init關鍵字之前放置convenience關鍵字，并使用空格將它們倆分開：
convenience init(parameters) {
statements
}
類的構造器代理規則
為了簡化指定構造器和便利構造器之間的調用關系，Swift 采用以下三條規則來限制構造器之間的代理調用：
規則 1
指定構造器必須調用其直接父類的的指定構造器。
規則 2
便利構造器必須調用同一類中定義的其它構造器。
規則 3
便利構造器必須最終導致一個指定構造器被調用。
一個更方便記憶的方法是：
- 指定構造器必須總是向上代理
- 便利構造器必須總是橫向代理
這些規則可以通過下面圖例來說明：
如圖所示，父類中包含一個指定構造器和兩個便利構造器。其中一個便利構造器調用了另外一個便利構造器，而后者又調用了唯一的指定構造器。這滿足了上面提到的規則 2 和 3。這個父類沒有自己的父類，所以規則 1 沒有用到。
子類中包含兩個指定構造器和一個便利構造器。便利構造器必須調用兩個指定構造器中的任意一個，因為它只能調用同一個類里的其他構造器。這滿足了上面提到的規則 2 和 3。而兩個指定構造器必須調用父類中唯一的指定構造器，這滿足了規則 1。
注意
這些規則不會影響類的實例如何創建。任何上圖中展示的構造器都可以用來創建完全初始化的實例。這些規則只影響類定義如何實現。
下面圖例中展示了一種涉及四個類的更復雜的類層級結構。它演示了指定構造器是如何在類層級中充當“管道”的作用，在類的構造器鏈上簡化了類之間的相互關系。
兩段式構造過程
Swift 中類的構造過程包含兩個階段。第一個階段，每個存儲型屬性被引入它們的類指定一個初始值。當每個存儲型屬性的初始值被確定后，第二階段開始，它給每個類一次機會，在新實例準備使用之前進一步定制它們的存儲型屬性。
兩段式構造過程的使用讓構造過程更安全，同時在整個類層級結構中給予了每個類完全的靈活性。兩段式構造過程可以防止屬性值在初始化之前被訪問，也可以防止屬性被另外一個構造器意外地賦予不同的值。
注意
Swift 的兩段式構造過程跟 Objective-C 中的構造過程類似。最主要的區別在于階段 1，Objective-C 給每一個屬性賦值0或空值（比如說0或nil）。Swift 的構造流程則更加靈活，它允許你設置定制的初始值，并自如應對某些屬性不能以0或nil作為合法默認值的情況。
Swift 編譯器將執行 4 種有效的安全檢查，以確保兩段式構造過程能不出錯地完成：
安全檢查 1
指定構造器必須保證它所在類引入的所有屬性都必須先初始化完成，之后才能將其它構造任務向上代理給父類中的構造器。
如上所述，一個對象的內存只有在其所有存儲型屬性確定之后才能完全初始化。為了滿足這一規則，指定構造器必須保證它所在類引入的屬性在它往上代理之前先完成初始化。
安全檢查 2
指定構造器必須先向上代理調用父類構造器，然后再為繼承的屬性設置新值。如果沒這么做，指定構造器賦予的新值將被父類中的構造器所覆蓋。
安全檢查 3
便利構造器必須先代理調用同一類中的其它構造器，然后再為任意屬性賦新值。如果沒這么做，便利構造器賦予的新值將被同一類中其它指定構造器所覆蓋。
安全檢查 4
構造器在第一階段構造完成之前，不能調用任何實例方法，不能讀取任何實例屬性的值，不能引用self作為一個值。
類實例在第一階段結束以前并不是完全有效的。只有第一階段完成后，該實例才會成為有效實例，才能訪問屬性和調用方法。
以下是兩段式構造過程中基于上述安全檢查的構造流程展示：
階段 1
- 某個指定構造器或便利構造器被調用。
- 完成新實例內存的分配，但此時內存還沒有被初始化。
- 指定構造器確保其所在類引入的所有存儲型屬性都已賦初值。存儲型屬性所屬的內存完成初始化。
- 指定構造器將調用父類的構造器，完成父類屬性的初始化。
- 這個調用父類構造器的過程沿著構造器鏈一直往上執行，直到到達構造器鏈的最頂部。
- 當到達了構造器鏈最頂部，且已確保所有實例包含的存儲型屬性都已經賦值，這個實例的內存被認為已經完全初始化。此時階段 1 完成。
階段 2
- 從頂部構造器鏈一直往下，每個構造器鏈中類的指定構造器都有機會進一步定制實例。構造器此時可以訪問
self、修改它的屬性并調用實例方法等等。 - 最終，任意構造器鏈中的便利構造器可以有機會定制實例和使用
self。
下圖展示了在假定的子類和父類之間的構造階段 1：
在這個例子中，構造過程從對子類中一個便利構造器的調用開始。這個便利構造器此時沒法修改任何屬性，它把構造任務代理給同一類中的指定構造器。
如安全檢查 1 所示，指定構造器將確保所有子類的屬性都有值。然后它將調用父類的指定構造器，并沿著構造器鏈一直往上完成父類的構造過程。
父類中的指定構造器確保所有父類的屬性都有值。由于沒有更多的父類需要初始化，也就無需繼續向上代理。
一旦父類中所有屬性都有了初始值，實例的內存被認為是完全初始化，階段 1 完成。
以下展示了相同構造過程的階段 2：
父類中的指定構造器現在有機會進一步來定制實例（盡管這不是必須的）。
一旦父類中的指定構造器完成調用，子類中的指定構造器可以執行更多的定制操作（這也不是必須的）。
最終，一旦子類的指定構造器完成調用，最開始被調用的便利構造器可以執行更多的定制操作。
構造器的繼承和重寫
跟 Objective-C 中的子類不同，Swift 中的子類默認情況下不會繼承父類的構造器。Swift 的這種機制可以防止一個父類的簡單構造器被一個更精細的子類繼承，并被錯誤地用來創建子類的實例。
注意
父類的構造器僅會在安全和適當的情況下被繼承。
假如你希望自定義的子類中能提供一個或多個跟父類相同的構造器，你可以在子類中提供這些構造器的自定義實現。
當你在編寫一個和父類中指定構造器相匹配的子類構造器時，你實際上是在重寫父類的這個指定構造器。因此，你必須在定義子類構造器時帶上override修飾符。即使你重寫的是系統自動提供的默認構造器，也需要帶上override修飾符。
正如重寫屬性，方法或者是下標，override修飾符會讓編譯器去檢查父類中是否有相匹配的指定構造器，并驗證構造器參數是否正確。
注意
當你重寫一個父類的指定構造器時，你總是需要寫override修飾符，即使你的子類將父類的指定構造器重寫為了便利構造器。
相反，如果你編寫了一個和父類便利構造器相匹配的子類構造器，由于子類不能直接調用父類的便利構造器，因此，嚴格意義上來講，你的子類并未對一個父類構造器提供重寫。最后的結果就是，你在子類中“重寫”一個父類便利構造器時，不需要加override前綴。
class A {
var a: Int
init(a: Int) {
self.a = a
}
convenience init() {
self.init(a: 1)
}
}
class B: A {
override init(a: Int) {
super.init(a: 2)
}
init() {
super.init(a: 2)
}
}
一般來說，子類的初始化順序是：
- 設置子類自己需要初始化的參數，power = 10
- 調用父類的相應的初始化方法，super.init()
- 對父類中的需要改變的成員進行設定，name = "tiger"
其中第三步是根據具體情況決定的，如果我們在子類中不需要對父類的成員做出改變的話，就不存在第 3 步。而在這種情況下，Swift 會自動地對父類的對應 init 方法進行調用，也就是說，第 2 步的 super.init() 也是可以不用寫的 (但是實際上還是調用的，只不過是為了簡便 Swift 幫我們完成了)。這種情況下的初始化方法看起來就很簡單：
class Cat {
var name: String
init() {
name = "cat"
}
}
class Tiger: Cat {
let power: Int
override init() {
power = 10
// super.init()
// name = "tiger"
}
}
可以省略的條件：
- 子類重寫父類的指定構造器
- 指定構造器沒有參數
- 父類只有一個指定構造器
- 子類中不需要對父類的成員做出改變
構造器的自動繼承
如上所述，子類在默認情況下不會繼承父類的構造器。但是如果滿足特定條件，父類構造器是可以被自動繼承的。在實踐中，這意味著對于許多常見場景你不必重寫父類的構造器，并且可以在安全的情況下以最小的代價繼承父類的構造器。
假設你為子類中引入的所有新屬性都提供了默認值，以下 2 個規則適用：
規則 1
如果子類沒有定義任何指定構造器，它將自動繼承所有父類的指定構造器。
規則 2
如果子類提供了所有父類指定構造器的實現——無論是通過規則 1 繼承過來的，還是提供了自定義實現——它將自動繼承所有父類的便利構造器。
即使你在子類中添加了更多的便利構造器，這兩條規則仍然適用。
指定構造器和便利構造器實踐
接下來的例子將在實踐中展示指定構造器、便利構造器以及構造器的自動繼承。這個例子定義了包含三個類Food、RecipeIngredient以及ShoppingListItem的類層次結構，并將演示它們的構造器是如何相互作用的。
類層次中的基類是Food，它是一個簡單的用來封裝食物名字的類。Food類引入了一個叫做name的String類型的屬性，并且提供了兩個構造器來創建Food實例：
class Food {
var name: String
init(name: String) {
self.name = name
}
convenience init() {
self.init(name: "[Unnamed]")
}
}
下圖中展示了Food的構造器鏈：
類類型沒有默認的逐一成員構造器，所以Food類提供了一個接受單一參數name的指定構造器。這個構造器可以使用一個特定的名字來創建新的Food實例：
let namedMeat = Food(name: "Bacon")
// namedMeat 的名字是 "Bacon”
Food類中的構造器init(name: String)被定義為一個指定構造器，因為它能確保Food實例的所有存儲型屬性都被初始化。Food類沒有父類，所以init(name: String)構造器不需要調用super.init()來完成構造過程。
Food類同樣提供了一個沒有參數的便利構造器init()。這個init()構造器為新食物提供了一個默認的占位名字，通過橫向代理到指定構造器init(name: String)并給參數name傳值[Unnamed]來實現：
let mysteryMeat = Food()
// mysteryMeat 的名字是 [Unnamed]
類層級中的第二個類是Food的子類RecipeIngredient。RecipeIngredient類用來表示食譜中的一項原料。它引入了Int類型的屬性quantity（以及從Food繼承過來的name屬性），并且定義了兩個構造器來創建RecipeIngredient實例：
class RecipeIngredient: Food {
var quantity: Int
init(name: String, quantity: Int) {
self.quantity = quantity
super.init(name: name)
}
override convenience init(name: String) {
self.init(name: name, quantity: 1)
}
}
下圖中展示了RecipeIngredient類的構造器鏈：
RecipeIngredient類擁有一個指定構造器init(name: String, quantity: Int)，它可以用來填充RecipeIngredient實例的所有屬性值。這個構造器一開始先將傳入的quantity參數賦值給quantity屬性，這個屬性也是唯一在RecipeIngredient中新引入的屬性。隨后，構造器向上代理到父類Food的init(name: String)。這個過程滿足兩段式構造過程中的安全檢查 1。
RecipeIngredient還定義了一個便利構造器init(name: String)，它只通過name來創建RecipeIngredient的實例。這個便利構造器假設任意RecipeIngredient實例的quantity為1，所以不需要顯式指明數量即可創建出實例。這個便利構造器的定義可以更加方便和快捷地創建實例，并且避免了創建多個quantity為1的RecipeIngredient實例時的代碼重復。這個便利構造器只是簡單地橫向代理到類中的指定構造器，并為quantity參數傳遞1。
注意，RecipeIngredient的便利構造器init(name: String)使用了跟Food中指定構造器init(name: String)相同的參數。由于這個便利構造器重寫了父類的指定構造器init(name: String)，因此必須在前面使用override修飾符（參見構造器的繼承和重寫）。
盡管RecipeIngredient將父類的指定構造器重寫為了便利構造器，它依然提供了父類的所有指定構造器的實現。因此，RecipeIngredient會自動繼承父類的所有便利構造器。
在這個例子中，RecipeIngredient的父類是Food，它有一個便利構造器init()。這個便利構造器會被RecipeIngredient繼承。這個繼承版本的init()在功能上跟Food提供的版本是一樣的，只是它會代理到RecipeIngredient版本的init(name: String)而不是Food提供的版本。
所有的這三種構造器都可以用來創建新的RecipeIngredient實例：
let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
類層級中第三個也是最后一個類是RecipeIngredient的子類，叫做ShoppingListItem。這個類構建了購物單中出現的某一種食譜原料。
購物單中的每一項總是從未購買狀態開始的。為了呈現這一事實，ShoppingListItem引入了一個布爾類型的屬性purchased，它的默認值是false。ShoppingListItem還添加了一個計算型屬性description，它提供了關于ShoppingListItem實例的一些文字描述：
class ShoppingListItem: RecipeIngredient {
var purchased = false
var description: String {
var output = "\(quantity) x \(name)"
output += purchased ? " ?" : " ?"
return output
}
}
注意
ShoppingListItem沒有定義構造器來為purchased提供初始值，因為添加到購物單的物品的初始狀態總是未購買。
由于它為自己引入的所有屬性都提供了默認值，并且自己沒有定義任何構造器，ShoppingListItem將自動繼承所有父類中的指定構造器和便利構造器。
下圖展示了這三個類的構造器鏈：
你可以使用全部三個繼承來的構造器來創建ShoppingListItem的新實例：
var breakfastList = [
ShoppingListItem(),
ShoppingListItem(name: "Bacon"),
ShoppingListItem(name: "Eggs", quantity: 6),
]
breakfastList[0].name = "Orange juice"
breakfastList[0].purchased = true
for item in breakfastList {
print(item.description)
}
// 1 x orange juice ?
// 1 x bacon ?
// 6 x eggs ?
如上所述，例子中通過字面量方式創建了一個數組breakfastList，它包含了三個ShoppingListItem實例，因此數組的類型也能被自動推導為[ShoppingListItem]。在數組創建完之后，數組中第一個ShoppingListItem實例的名字從[Unnamed]更改為Orange juice，并標記為已購買。打印數組中每個元素的描述顯示了它們都已按照預期被賦值。
可失敗構造器
如果一個類、結構體或枚舉類型的對象，在構造過程中有可能失敗，則為其定義一個可失敗構造器。這里所指的“失敗”是指，如給構造器傳入無效的參數值，或缺少某種所需的外部資源，又或是不滿足某種必要的條件等。
為了妥善處理這種構造過程中可能會失敗的情況。你可以在一個類，結構體或是枚舉類型的定義中，添加一個或多個可失敗構造器。其語法為在init關鍵字后面添加問號(init?)。
注意
可失敗構造器的參數名和參數類型，不能與其它非可失敗構造器的參數名，及其參數類型相同。
可失敗構造器會創建一個類型為自身類型的可選類型的對象。你通過return nil語句來表明可失敗構造器在何種情況下應該“失敗”。
注意
嚴格來說，構造器都不支持返回值。因為構造器本身的作用，只是為了確保對象能被正確構造。因此你只是用return nil表明可失敗構造器構造失敗，而不要用關鍵字return來表明構造成功。
struct Animal {
let species: String
init?(species: String) {
if species.isEmpty { return nil }
self.species = species
}
}
構造失敗的傳遞
類，結構體，枚舉的可失敗構造器可以橫向代理到類型中的其他可失敗構造器。類似的，子類的可失敗構造器也能向上代理到父類的可失敗構造器。
無論是向上代理還是橫向代理，如果你代理到的其他可失敗構造器觸發構造失敗，整個構造過程將立即終止，接下來的任何構造代碼不會再被執行。
注意
可失敗構造器也可以代理到其它的非可失敗構造器。通過這種方式，你可以增加一個可能的失敗狀態到現有的構造過程中。
下面這個例子，定義了一個名為CartItem的Product類的子類。這個類建立了一個在線購物車中的物品的模型，它有一個名為quantity的常量存儲型屬性，并確保該屬性的值至少為1：
class Product {
let name: String
init?(name: String) {
if name.isEmpty { return nil }
self.name = name
}
}
class CartItem: Product {
let quantity: Int
init?(name: String, quantity: Int) {
if quantity < 1 { return nil }
self.quantity = quantity
super.init(name: name)
}
}
CartItem 可失敗構造器首先驗證接收的 quantity 值是否大于等于 1 。倘若 quantity 值無效，則立即終止整個構造過程，返回失敗結果，且不再執行余下代碼。同樣地，Product 的可失敗構造器首先檢查 name 值，假如 name 值為空字符串，則構造器立即執行失敗。
如果你通過傳入一個非空字符串 name 以及一個值大于等于 1 的 quantity 來創建一個 CartItem 實例，那么構造方法能夠成功被執行：
if let twoSocks = CartItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
// 打印 "Item: sock, quantity: 2”
倘若你以一個值為 0 的 quantity 來創建一個 CartItem 實例，那么將導致 CartItem 構造器失敗：
if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
print("Unable to initialize zero shirts")
}
// 打印 "Unable to initialize zero shirts”
同樣地，如果你嘗試傳入一個值為空字符串的 name來創建一個 CartItem 實例，那么將導致父類 Product 的構造過程失敗：
if let oneUnnamed = CartItem(name: "", quantity: 1) {
print("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
} else {
print("Unable to initialize one unnamed product")
}
// 打印 "Unable to initialize one unnamed product”
重寫一個可失敗構造器
如同其它的構造器，你可以在子類中重寫父類的可失敗構造器。或者你也可以用子類的非可失敗構造器重寫一個父類的可失敗構造器。這使你可以定義一個不會構造失敗的子類，即使父類的構造器允許構造失敗。
注意，當你用子類的非可失敗構造器重寫父類的可失敗構造器時，向上代理到父類的可失敗構造器的唯一方式是對父類的可失敗構造器的返回值進行強制解包。
注意
你可以用非可失敗構造器重寫可失敗構造器，但反過來卻不行。
下例定義了一個名為Document的類，name屬性的值必須為一個非空字符串或nil，但不能是一個空字符串：
class Document {
var name: String?
// 該構造器創建了一個 name 屬性的值為 nil 的 document 實例
init() {}
// 該構造器創建了一個 name 屬性的值為非空字符串的 document 實例
init?(name: String) {
self.name = name
if name.isEmpty { return nil }
}
}
下面這個例子，定義了一個Document類的子類AutomaticallyNamedDocument。這個子類重寫了父類的兩個指定構造器，確保了無論是使用init()構造器，還是使用init(name:)構造器并為參數傳遞空字符串，生成的實例中的name屬性總有初始"[Untitled]"：
class AutomaticallyNamedDocument: Document {
override init() {
super.init()
self.name = "[Untitled]"
}
override init(name: String) {
super.init()
if name.isEmpty {
self.name = "[Untitled]"
} else {
self.name = name
}
}
}
AutomaticallyNamedDocument用一個非可失敗構造器init(name:)重寫了父類的可失敗構造器init?(name:)。因為子類用另一種方式處理了空字符串的情況，所以不再需要一個可失敗構造器，因此子類用一個非可失敗構造器代替了父類的可失敗構造器。
你可以在子類的非可失敗構造器中使用強制解包來調用父類的可失敗構造器。比如，下面的UntitledDocument子類的name屬性的值總是"[Untitled]"，它在構造過程中使用了父類的可失敗構造器init?(name:)：
class UntitledDocument: Document {
override init() {
super.init(name: "[Untitled]")!
}
}
在這個例子中，如果在調用父類的可失敗構造器init?(name:)時傳入的是空字符串，那么強制解包操作會引發運行時錯誤。不過，因為這里是通過非空的字符串常量來調用它，所以并不會發生運行時錯誤。
必要構造器
在類的構造器前添加required修飾符表明所有該類的子類都必須實現該構造器：
class SomeClass {
required init() {
// 構造器的實現代碼
}
}
在子類重寫父類的必要構造器時，必須在子類的構造器前也添加required修飾符，表明該構造器要求也應用于繼承鏈后面的子類。在重寫父類中必要的指定構造器時，不需要添加override修飾符：
class SomeSubclass: SomeClass {
required init() {
// 構造器的實現代碼
}
}
注意
如果子類繼承的構造器能滿足必要構造器的要求，則無須在子類中顯式提供必要構造器的實現。
析構過程（Deinitialization）
析構器只適用于類類型，當一個類的實例被釋放之前，析構器會被立即調用。析構器用關鍵字deinit來標示，類似于構造器要用init來標示。
析構過程原理
Swift 會自動釋放不再需要的實例以釋放資源。當你的實例被釋放時不需要手動地去清理。但是，當使用自己的資源時，你可能需要進行一些額外的清理。
在類的定義中，每個類最多只能有一個析構器，而且析構器不帶任何參數，如下所示：
deinit {
// 執行析構過程
}
析構器是在實例釋放發生前被自動調用。你不能主動調用析構器。子類繼承了父類的析構器，并且在子類析構器實現的最后，父類的析構器會被自動調用。即使子類沒有提供自己的析構器，父類的析構器也同樣會被調用。
因為直到實例的析構器被調用后，實例才會被釋放，所以析構器可以訪問實例的所有屬性，并且可以根據那些屬性可以修改它的行為）。
class Person {
var name: String
init(name: String) {
self.name = name
print("\(name) is being initialized")
}
deinit {
print("\(name) is being deinitialized")
}
}
var p: Person?
p = Person(name: "dd")
p = nil
