21bc436853ba3d270aa9092a158ff847cebc73c78a952-qEIYI8_fw658.jpeg

構造過程是為了使用某個類、結構體或枚舉類型的實例而進行的準備過程。其實就是初始化。
構造過程是通過定義構造器（Initializers）來實現的，這些構造器可以看做是用來創建特定類型實例的特殊方法。與 Objective-C 中的構造器不同，Swift 的構造器無需返回值，它們的主要任務是保證新實例在第一次使用前完成正確的初始化。

類實例也可以通過定義析構器（deinitializer）在類實例釋放之前執行特定的清除工作。

存儲型屬性的初始賦值

類和結構體在實例創建時，必須為所有存儲型屬性設置合適的初始值。存儲型屬性的值不能處于一個未知的狀態。

你可以在構造器中為存儲型屬性賦初值，也可以在定義屬性時為其設置默認值。以下章節將詳細介紹這兩種方法。

注意：當你為存儲型屬性設置默認值或者在構造器中為其賦值時，它們的值是被直接設置的，不會觸發任何屬性觀測器（property observers）。

構造器

構造器在創建某特定類型的新實例時調用。它的最簡形式類似于一個不帶任何參數的實例方法，以關鍵字init命名。

init() {
    // perform some initialization here
}

下面例子中定義了一個用來保存華氏溫度的結構體Fahrenheit，它擁有一個Double類型的存儲型屬性temperature：

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0 //使用構造器初始化
    }
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
// Prints "The default temperature is 32.0° Fahrenheit"

該結構定義了一個初始化，init，不帶任何參數，它與值初始化存儲溫度32.0（水華氏度冰點）。

默認屬性值

如前所述，你可以在構造器中為存儲型屬性設置初始值；同樣，你也
可以在屬性聲明時為其設置默認值。

注意：如果一個屬性總是使用同一個初始值，可以為其設置一個默認值。無論定義默認值還是在構造器中賦值，最終它們實現的效果是一樣的，只不過默認值跟屬性構造過程結合的更緊密。使用默認值能讓你的構造器更簡潔、更清晰，且能通過默認值自動推導出屬性的類型；同時，它也能讓你充分利用默認構造器、構造器繼承等特性。

//你可以使用更簡單的方式在定義結構體Fahrenheit時為屬性temperature設置默認值：
struct Fahrenheit { 
    var temperature = 32.0 
} 

自定義構造過程

你可以通過輸入參數和可選屬性類型來定制構造過程，也可以在構造過程中修改常量屬性。這些都將在后面章節中提到。

構造參數
你可以在定義構造器時提供構造參數，為其提供定制化構造所需值的類型和名字。構造器參數的功能和語法跟函數和方法參數相同。

struct Celsius { 
    var temperatureInCelsius: Double = 0.0 
    init(fromFahrenheit fahrenheit: Double) { 
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8 
    } 
    init(fromKelvin kelvin: Double) { 
        temperatureInCelsius = kelvin - 273.15 
    } 
} 
 
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0) 
// boilingPointOfWater.temperatureInCelsius 是 100.0 
let freezingPointOfWater = Celsius(fromKelvin: 273.15) 
// freezingPointOfWater.temperatureInCelsius 是 0.0” 

第一個構造器擁有一個構造參數，其外部名字為fromFahrenheit，內部名字為fahrenheit；第二個構造器也擁有一個構造參數，其外部名字為fromKelvin，內部名字為kelvin。這兩個構造器都將唯一的參數值轉換成攝氏溫度值，并保存在屬性temperatureInCelsius中。

內部和外部參數名

跟函數和方法參數相同，構造參數也存在一個在構造器內部使用的參數名字和一個在調用構造器時使用的外部參數名字。

然而，構造器并不像函數和方法那樣在括號前有一個可辨別的名字。所以在調用構造器時，主要通過構造器中的參數名和類型來確定需要調用的構造器。正因為參數如此重要，如果你在定義構造器時沒有提供參數的外部名字，Swift 會為每個構造器的參數自動生成一個跟內部名字相同的外部名，就相當于在每個構造參數之前加了一個哈希符號。
Color提供了一個構造器，其中包含三個Double類型的構造參數：

struct Color { 
//    var red = 0.0, green = 0.0, blue = 0.0  //如果設置屬性默認值，則必須聲明為可變
   let red, green, blue: Double
//沒有聲明外部參數值， 則默認使用內部參數值
    init(red: Double, green: Double, blue: Double) { 
        self.red   = red 
        self.green = green 
        self.blue  = blue 
    } 
} 
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
//如果不使用外部參數則會報錯
//let veryGreen = Color(0.0, 1.0, 0.0) 
//missing argument labels 'red:green:blue:' in call
//let veryGreen = Color(0.0, 1.0, 0.0)
//                     ^
//                      red: green:  blue: 

如果你真的不想寫外部參數值則可以把外部參數值以_代替
上面的例子可以改寫為

struct Color {
    let red, green, blue: Double
/_與內部參數之間要有一個空格
    init(_ red: Double, _ green: Double, _ blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
}

let magenta = Color(1.0, 1.0, 0.0)

此外，你還可以讓某些參數好含有外部參數，某些不含有

struct Color {
    let red, green, blue: Double
//第一個含有外部參數，第二個省略外部參數，第三個則默認使用內部參數值
    init(colorRed red: Double, _ green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
}

let magenta = Color(colorRed: 1.0, 1.0, blue: 0.0)

可選屬性類型

如果你定制的類型包含一個邏輯上允許取值為空的存儲型屬性--不管是因為它無法在初始化時賦值，還是因為它可以在之后某個時間點可以賦值為空--你都需要將它定義為可選類型optional type。可選類型的屬性將自動初始化為空nil，表示這個屬性是故意在初始化時設置為空的。
下面例子中定義了類SurveyQuestion，它包含一個可選字符串屬性response：

class SurveyQuestion {
    var text: String
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(self.text)
    }
}
let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
cheeseQuestion.ask()
// 輸出 "Do you like cheese?"
cheeseQuestion.response = "Yes, I do like cheese."

當SurveyQuestion實例化時，它將自動賦值為空nil，表明暫時還不存在此字符串。

默認構造器
Swift 將為所有屬性已提供默認值的且自身沒有定義任何構造器的結構體或基類，提供一個默認的構造器。這個默認構造器將簡單的創建一個所有屬性值都設置為默認值的實例。

class ShoppingListItem {
//與OC不同， 類里面的所以屬性，無論是使用默認屬性賦值還是構造器賦值,必須有要賦初值。而只有可選類型不需要，可選類型如果沒有初始值，會自動推斷。
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()

結構體的逐一成員構造器

除上面提到的默認構造器，如果結構體對所有存儲型屬性提供了默認值且自身沒有提供定制的構造器，它們能自動獲得一個逐一成員構造器。

逐一成員構造器是用來初始化結構體新實例里成員屬性的快捷方法。我們在調用逐一成員構造器時，通過與成員屬性名相同的參數名進行傳值來完成對成員屬性的初始賦值。

下面例子中定義了一個結構體Size，它包含兩個屬性width和height。Swift 可以根據這兩個屬性的初始賦值0.0自動推導出它們的類型Double。

由于這兩個存儲型屬性都有默認值，結構體Size自動獲得了一個逐一成員構造器 init(width:height:)。 你可以用它來為Size創建新的實例：

struct Size { 
    var width = 0.0, height = 0.0 
} 
let twoByTwo = Size(width: 2.0, height: 2.0) 

值類型的構造器代理

構造器可以通過調用其它構造器來完成實例的部分構造過程。這一過程稱為構造器代理，它能減少多個構造器間的代碼重復。

構造器代理的實現規則和形式在值類型和類類型中有所不同。值類型（結構體和枚舉類型）不支持繼承，所以構造器代理的過程相對簡單，因為它們只能代理任務給本身提供的其它構造器。類則不同，它可以繼承自其它類（請參考繼承），這意味著類有責任保證其所有繼承的存儲型屬性在構造時也能正確的初始化。

對于值類型，你可以使用self.init在自定義的構造器中引用其它的屬于相同值類型的構造器。并且你只能在構造器內部調用self.init。

注意，如果你為某個值類型定義了一個定制的構造器，你將無法訪問到默認構造器（如果是結構體，則無法訪問逐一對象構造器）。這個限制可以防止你在為值類型定義了一個更復雜的，完成了重要準備構造器之后，別人還是錯誤的使用了那個自動生成的構造器。

注意：假如你想通過默認構造器、逐一對象構造器以及你自己定制的構造器為值類型創建實例，我們建議你將自己定制的構造器寫到擴展（extension）中，而不是跟值類型定義混在一起。
下面例子將定義一個結構體Rect，用來展現幾何矩形。這個例子需要兩個輔助的結構體Size和Point，它們各自為其所有的屬性提供了初始值0.0。

struct Size { 
    var width = 0.0, height = 0.0 
} 
struct Point { 
    var x = 0.0, y = 0.0 
} 

你可以通過以下三種方式為Rect創建實例--使用默認的0值來初始化origin和size屬性；使用特定的origin和size實例來初始化；使用特定的center和size來初始化。在下面Rect結構體定義中，我們為著三種方式提供了三個自定義的構造器：

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) 
    } 
} 

第一個Rect構造器init()，在功能上跟沒有自定義構造器時自動獲得的默認構造器是一樣的。這個構造器是一個空函數，使用一對大括號{}來描述，它沒有執行任何定制的構造過程。調用這個構造器將返回一個Rect實例，它的origin和size屬性都使用定義時的默認值Point(x: 0.0, y: 0.0)和Size(width: 0.0, height: 0.0)：

let basicRect = Rect() 
// basicRect 的原點是 (0.0, 0.0)，尺寸是 (0.0, 0.0) 

第二個Rect構造器init(origin:size:)，在功能上跟結構體在沒有自定義構造器時獲得的逐一成員構造器是一樣的。這個構造器只是簡單的將origin和size的參數值賦給對應的存儲型屬性：

let originRect = Rect(origin: Point(x: 2.0, y: 2.0), 
    size: Size(width: 5.0, height: 5.0)) 
// originRect 的原點是 (2.0, 2.0)，尺寸是 (5.0, 5.0) 

第三個Rect構造器init(center:size:)稍微復雜一點。它先通過center和size的值計算出origin的坐標。然后再調用（或代理給）init(origin:size:)構造器來將新的origin和size值賦值到對應的屬性中：

let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0)) 
// centerRect 的原點是 (2.5, 2.5)，尺寸是 (3.0, 3.0)

構造器init(center:size:)可以自己將origin和size的新值賦值到對應的屬性中。然而盡量利用現有的構造器和它所提供的功能來實現init(center:size:)的功能，是更方便、更清晰和更直觀的方法。

注意：如果你想用另外一種不需要自己定義init()和init(origin:size:)的方式來實現這個例子，請參考擴展。

指定構造器和便利構造器

指定構造器和便利構造器的語法
類的指定構造器的寫法跟值類型簡單構造器一樣：

init(parameters) { 
    statements 
} 

便利構造器也采用相同樣式的寫法，但需要在init關鍵字之前放置convenience關鍵字，并使用空格將它們倆分開：

convenience init(parameters) { 
   statements 
} 

指定構造器和便利構造器實戰
接下來的例子將在實戰中展示指定構造器、便利構造器和自動構造器的繼承。它定義了包含三個類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的構造器鏈

8370_140612135829_1.png

類沒有提供一個默認的逐一成員構造器，所以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) 
    } 
    convenience init(name: String) { 
        self.init(name: name, quantity: 1) 
    } 
} 

下圖中展示了RecipeIngredient類的構造器鏈：

8370_140612135926_1.png

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實例。這個便利構造器只是簡單的將任務代理給了同一類里提供的指定構造器。

注意，RecipeIngredient的便利構造器init(name: String)使用了跟Food中指定構造器init(name: String)相同的參數。盡管RecipeIngredient這個構造器是便利構造器，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。這個類構建了購物單中出現的某一種調味料。

購物單中的每一項總是從unpurchased未購買狀態開始的。為了展現這一事實，ShoppingListItem引入了一個布爾類型的屬性purchased，它的默認值是false。ShoppingListItem還添加了一個計算型屬性description，它提供了關于ShoppingListItem實例的一些文字描述：

class ShoppingListItem: RecipeIngredient { 
    var purchased = false 
    var description: String { 
    var output = "\(quantity) x \(name.lowercaseString)" 
        output += purchased ? " ?" : " ?" 
        return output 
    } 
} 

注意：ShoppingListItem沒有定義構造器來為purchased提供初始化值，這是因為任何添加到購物單的項的初始狀態總是未購買。

由于它為自己引入的所有屬性都提供了默認值，并且自己沒有定義任何構造器，ShoppingListItem將自動繼承所有父類中的指定構造器和便利構造器。

下圖種展示了所有三個類的構造器鏈：

8370_140612140024_1.png

你可以使用全部三個繼承來的構造器來創建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 { 
    println(item.description) 
} 
// 1 x orange juice ? 
// 1 x bacon ? 
// 6 x eggs ? 

如上所述，例子中通過字面量方式創建了一個新數組breakfastList，它包含了三個新的ShoppingListItem實例，因此數組的類型也能自動推導為ShoppingListItem[]。在數組創建完之后，數組中第一個ShoppingListItem實例的名字從[Unnamed]修改為Orange juice，并標記為已購買。接下來通過遍歷數組每個元素并打印它們的描述值，展示了所有項當前的默認狀態都已按照預期完成了賦值。

通過閉包和函數來設置屬性的默認值

如果某個存儲型屬性的默認值需要特別的定制或準備，你就可以使用閉包或全局函數來為其屬性提供定制的默認值。每當某個屬性所屬的新類型實例創建時，對應的閉包或函數會被調用，而它們的返回值會當做默認值賦值給這個屬性。

這種類型的閉包或函數一般會創建一個跟屬性類型相同的臨時變量，然后修改它的值以滿足預期的初始狀態，最后將這個臨時變量的值作為屬性的默認值進行返回。

下面列舉了閉包如何提供默認值的代碼概要：

class SomeClass { 
    let someProperty: SomeType = { 
        // 在這個閉包中給 someProperty 創建一個默認值 
        // someValue 必須和 SomeType 類型相同 
        return someValue 
        }() 
} 

注意閉包結尾的大括號后面接了一對空的小括號。這是用來告訴 Swift 需要立刻執行此閉包。如果你忽略了這對括號，相當于是將閉包本身作為值賦值給了屬性，而不是將閉包的返回值賦值給屬性。

注意：如果你使用閉包來初始化屬性的值，請記住在閉包執行時，實例的其它部分都還沒有初始化。這意味著你不能夠在閉包里訪問其它的屬性，就算這個屬性有默認值也不允許。同樣，你也不能使用隱式的self屬性，或者調用其它的實例方法。