//: Playground - noun: a place where people can play

import UIKit

// # define: 初始化是為類觅捆、結(jié)構(gòu)體或者枚舉準(zhǔn)備實(shí)例的過程,目的是給實(shí)例里的每一個(gè)存儲屬性設(shè)置一個(gè)初始值并且執(zhí)行其他配置.

// # 為存儲屬性設(shè)置初始化值
// 當(dāng)你給一個(gè)存儲屬性分配默認(rèn)值，或者在一個(gè)初始化器里設(shè)置它的初始值的時(shí)候吕粗，不會(huì)調(diào)用任何屬性監(jiān)聽器。

// # 自定義初始化
// 可選類型的屬性自動(dòng)地初始化為 nil,相當(dāng)于自帶默認(rèn)= nil.當(dāng)然也可以對其進(jìn)行初始化
class SurveyQuestion {
    var text: String
    var response: String? = "I don't think so..."
    init(text: String) {
        self.text = text
    }
}
let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
cheeseQuestion.response!
// 在初始化過程中,可以給常量屬性賦值,一旦被賦值過一次,此后就不能再被賦值(不管在不在init中)

// # 默認(rèn)初始化器
// 類:無自定義初始化器&&存儲變量都有默認(rèn)值&&是基類:自動(dòng)獲得:默認(rèn)初始化器
// 結(jié)構(gòu)體:無自定義初始化器:自動(dòng)獲得:成員初始化器;無自定義初始化器&&存儲變量都有默認(rèn)值:自動(dòng)獲得:成員初始化器和默認(rèn)初始化器
// 如果想要自定義類型也能夠使用默認(rèn)初始化器或成員初始化器初始化,就自定義初始化器寫在擴(kuò)展里垃僚。***如果擴(kuò)展的init()和默認(rèn)初始化器同名怎辦???

// # 值類型的初始化器委托
// 值類型初始化器可以調(diào)用其他初始化器來執(zhí)行部分實(shí)例的初始化。使用self.init在一個(gè)init中調(diào)用同類型的其他init.類必須用convenience標(biāo)記
struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
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)
    }
}

// # 類的繼承和初始化
// 指定初始化器:主要初始化器,調(diào)用合適的父類初始化器來繼續(xù)初始化過程.每個(gè)類至少要有一個(gè)指定初始化器(含默認(rèn)初始化器)
// 便捷初始化器:在相同的類里定義一個(gè)便捷初始化器來調(diào)用一個(gè)指定的初始化器.在init關(guān)鍵字前加上convenience.作用是為指定初始化器傳遞一些參數(shù)(比如默認(rèn)),這樣更加方便.
class Prisoner {
    var name: String
    var age: Int
    var anythingToSay: String
    init(name: String, age: Int, anythingToSay: String = "") {
        self.name = name
        self.age = age
        self.anythingToSay = anythingToSay
    }
    /*
    init(name: String, age: Int) {
        self.name = name
        self.age = age
        self.anythingToSay = "Nothing"
    }*/
    convenience init() {
        // 優(yōu)先調(diào)用后一個(gè)init,沒有的時(shí)候才調(diào)用前者
        self.init(name: "", age: 0)
    }
}

// 類類型的初始化器委托規(guī)則***
// 1.指定初始化器必須從它的直系父類調(diào)用指定初始化器澳骤。向上委托
// 2.便捷初始化器必須從相同的類里調(diào)用另一個(gè)初始化器,并且最終必須在這個(gè)類中調(diào)用一個(gè)指定初始化器阀圾。橫向委托
// 兩段式初始化的安全檢查規(guī)則***
// 1.指定初始化器必須保證在向上委托給父類初始化器之前立倍，其所在類新引入的所有屬性都要初始化完成灭红。
// 2.指定初始化器必須先向上委托父類初始化器，然后才能為繼承的屬性設(shè)置新值口注。
// 3.便捷初始化器必須先委托同類中的其它初始化器变擒，然后再為任意屬性賦新值。
// 4.初始化器在第一階段初始化完成之前寝志，不能調(diào)用任何實(shí)例方法赁项、不能讀取任何實(shí)例屬性的值，也不能引用 self 作為值(但是可用self.xxx為屬性賦初值)或調(diào)用其他初始化器,執(zhí)行完第一段,才算是有了這個(gè)類實(shí)例.
// 兩段式初始化的過程***
// 調(diào)用便捷初始化器—(-調(diào)用其他便捷初始化器-)—調(diào)用同一類中的指定初始化器并初始化該類引入的屬性—(—調(diào)用父類指定初始化器并初始化該類引入的屬性—)-基類初始化完畢,第一階段完成,實(shí)例誕生—修改初始化的內(nèi)容或者調(diào)用self等進(jìn)一步初始化—(—返回子類指定初始化器進(jìn)一步初始化—)(-返回到便捷初始化器并修改實(shí)例的屬性值—)—返回到調(diào)用的便捷初始化器并修改實(shí)例的屬性值—-完成
// 初始化器的繼承和重寫***
// Swift子類默認(rèn)不會(huì)繼承父類的初始化器.如果父類指定初始化器與子類初始化器(指定或便捷)重名必須加上override修飾符.加上override的意義為:Swift可以數(shù)是否父類所有指定初始化器都被重寫,如果是,將會(huì)把父類所有便捷初始化器贈(zèng)送給子類.其他與自定義子類初始化器沒有什么區(qū)別,比如都需要調(diào)用父類的指定初始化器(對指定初始化器)或子類的其他初始化器(對便捷初始化器),且在引入的屬性初始化完成后.
// 基類.它的指定初始化器是默認(rèn)初始化器
class Vehicle {
    var numberOfWheels = 0
    var description: String {
        return "\(numberOfWheels) wheel(s)"
    }
}
class Bicycle: Vehicle {
    var hasBasket: Bool
    override init() {
        hasBasket = true // 引入的屬性初始化
        super.init() // 子類初始化器必須要調(diào)用父類的指定初始化器
        numberOfWheels = 2 // 修改相關(guān)值,因?yàn)楦割惖某跏蓟鞑惶糜?    }
}
// 自動(dòng)初始化器的繼承規(guī)則***
// 1.如果子類沒有定義任何指定初始化器而且引入的新屬性都有默認(rèn)值澈段，它會(huì)自動(dòng)繼承父類所有的指定初始化器和便捷初始化器悠菜。???
// 2.如果子類override了所有父類指定初始化器,將自動(dòng)繼承父類所有便捷初始化器“芨唬可以將父類指定初始化器override為指定初始化器或便捷初始化器.往下看
class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}
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)
    } // 將繼承父類所有便捷初始化器悔醋。
    /* OR:
    override init(name: String) {
        super.init(name: name)
    }
    */
}
let oneMysteryItem = RecipeIngredient()
oneMysteryItem.name
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
class ShoppingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\(quantity) \(name)"
        output += purchased ? " Yes" : " No"
        return output
    }
}
var breakfastList = [
    ShoppingListItem(),
    ShoppingListItem(name: "Bacon"),
    ShoppingListItem(name: "Eggs", quantity: 6),
] // trick: 長數(shù)組的創(chuàng)建格式
breakfastList[0].name = "Orange juice"
breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}

// # 可失敗初始化器
// 不能定義可失敗和非可失敗的初始化器為相同的形式參數(shù)類型和名稱。
// 嚴(yán)格來講兽叮，初始化器不會(huì)有返回值芬骄。相反，它們的角色是確保在初始化結(jié)束時(shí)鹦聪， self 能夠被正確初始化账阻。雖然寫了 return nil 來觸發(fā)初始化失敗，但是不能使用 return 關(guān)鍵字來表示初始化成功了泽本。
// trick: 類型轉(zhuǎn)換
var a = Int(exactly: 3.14)
struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}
let someCreature = Animal(species: "Giraffe") // someCreature is of type Animal?, not Animal
someCreature!.species
// 枚舉的可失敗初始化器***
enum MyTemperatureUnit {
    case Kelvin, Celsius, Fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .Kelvin
        case "C":
            self = .Celsius
        case "F":
            self = .Fahrenheit
        default:
            return nil
        }
    }
}
// 帶有原始值的枚舉會(huì)自動(dòng)獲得一個(gè)可失敗的初始化器init?(rawValue:)
enum TemperatureUnit: Character {
    case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
}
let fahrenheitUnit = TemperatureUnit(rawValue: "F")
let unknownUnit = TemperatureUnit(rawValue: "X")
// 類淘太，結(jié)構(gòu)體或枚舉的可失敗初始化器可以橫向委托到同一個(gè)類，結(jié)構(gòu)體或枚舉里的另一個(gè)可失敗初始化器规丽。類似地蒲牧，子類的可失敗初始化器可以向上委托到父類的可失敗初始化器。在任何位置都可能導(dǎo)致整個(gè)實(shí)例初始化失敗而成為nil
// 可失敗初始化器也可以委托其他的非可失敗初始化器赌莺。通過這個(gè)方法冰抢，可以為已有的初始化過程添加初始化失敗的條件。
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)
    }
}
let twoSocks = CartItem(name: "sock", quantity: 2)
let zeroShirts = CartItem(name: "shirt", quantity: 0)
let oneUnnamed = CartItem(name: "", quantity: 1)
// 重寫可失敗初始化器
// 可以用一個(gè)非可失敗初始化器重寫一個(gè)可失敗初始化器艘狭，但反過來是不行的挎扰。
// 下面的以下定義了一個(gè)名為 Document 的類翠订。這個(gè)類建模了一個(gè)文檔，其中的 name 屬性要么是一個(gè)非空的字符串值要么為 nil 遵倦，但不能是一個(gè)空字符串：
class Document {
    var name: String?
    init() {}
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}
class AutomaticallyNamedDocument: Document {
    override init() {
        super.init()
        self.name = "[Untitled]"
    }
    override init(name: String) {
        super.init() // 其他的改變必須在super.init()之后,這就是兩段式初始化
        if name.isEmpty {
            self.name = "[Untitled]"
        } else {
            self.name = name
        }
    }
}
class UntitledDocument: Document {
    override init() {
        super.init(name: "[Untitled]")!// 強(qiáng)制展開父類的可失敗初始化器,因?yàn)檫@里肯定不會(huì)失敗
    }
}
// 隱式展開的可失敗初始化器init!失敗時(shí)會(huì)終止程序

// # 必要初始化器
// 在類的初始化器前添加 required  修飾符來表明所有該類的子類都必須實(shí)現(xiàn)該初始化器.
// 當(dāng)子類重寫父類的必要初始化器時(shí)尽超，必須在子類的初始化器前同樣添加 required 修飾符以確保當(dāng)其它類繼承該子類時(shí)，該初始化器同為必要初始化器骇吭。不需要添加 override 修飾符.
// 注意:如果子類繼承的初始化器能夠滿足require需求橙弱，則無需顯式地在子類中提供必要初始化器的實(shí)現(xiàn)歧寺。默認(rèn)不繼承,但是也可能繼承便捷初始化器???

// # 通過閉包和函數(shù)來設(shè)置屬性的默認(rèn)值
// 實(shí)例的初始化過程中,閉包或函數(shù)提供存儲屬性的默認(rèn)值
// trick:閉包花括號的結(jié)尾跟一個(gè)沒有參數(shù)的圓括號燥狰。這是告訴 Swift 立即執(zhí)行閉包。如果忽略了這對圓括號斜筐，你就會(huì)把閉包作為值賦給了屬性龙致，并且不會(huì)返回閉包的值。***
// 使用了閉包來初始化屬性顷链，在閉包執(zhí)行的時(shí)候目代，實(shí)例的其他部分還沒有被初始化,不能使用.
// 一個(gè)國際象棋棋盤建立的例子
// trick:二維數(shù)組用法
struct Chessboard {
    let boardColors: [Bool] = {
        var temporaryBoard = [Bool]()
        var isBlack = false
        for i in 1...8 {
            for j in 1...8 {
                temporaryBoard.append(isBlack)
                isBlack = !isBlack
            }
            isBlack = !isBlack
        }
        return temporaryBoard
    }()
    func squareIsBlackAt(row: Int, column: Int) -> Bool {
        assert(row >= 0 || row <= 7 || column >= 0 || column <= 7, "Index out of range.") // 斷言是不滿足布爾條件時(shí)觸發(fā)
        return boardColors[(row * 8) + column]
    }
}
let board = Chessboard()
print(board.squareIsBlackAt(row: 0, column: 1))
print(board.squareIsBlackAt(row: 7, column: 7))