//swift的构造器(Initilizer)和析构器(Deinitializer)
//构造器并不像函数和方法那样在括号前有一个可辨别的名字。所以在调用构造器时，主要通过构造器中的参数名和类型来确定需要调用的构造器。 正因为参数如此重要，如果你在定义构造器时没有提供参数的外部名字，Swift 会为每个构造器的参数自动生成一个跟内部名字相同的外部名，就相当于在每个构造参数之前加了一个哈希符号。

import Foundation

//默认构造器 init()
struct Fahrenheit {

    var temperature:Double
    init() {
    temperature = 32.0
    }

}
var f = Fahrenheit() //调用默认构造器,没有参数,没有返回值
print("the default temperature=\(f.temperature)")


//逐一成员构造器---只针对结构体..类没有该构造器
//如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。

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

struct Point {
    var x = 0.0,y = 0.0
}


//Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类，提供一个默认的构造器

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()//默认构造器




//自定义构造器 init(fromFahrenheit:) 和init(fromKelvin:)
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 is 100.0
let freezingPointOfWater = Celsius(fromKelvin:273.15)
// freezingPointOfWater.temperatureInCelsius is 0.0

//只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。 对某个类实例来说，它的常量属性只能在定义它的类的构造过程中修改；不能在子类中修改。

class SurveyQuestion {
    let text: String //常量值,但不能初始化一个具体的值,可以是可选值
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
var a  = SurveyQuestion(text: "dddd")
a.ask();



//如果定义的类型包含一个可以为空的存储型属性，需要将其定义为可选类型 (optional type)， 则自动初始化为nil，表示这个属性是故意初始化设置为空的
class SurveyQuestion1 {
    var text: String
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
cheeseQuestion.ask()
// prints "Do you like cheese?"
cheeseQuestion.response = "Yes,I do like cheese."
//构造器代理

//构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。 就是嵌套构造器方法 对于值类型，你可以使用self.init在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用self.init。

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

//5.类的继承和构造过程
//类里所有的存储类型属性包括继承父类的属性都需要在构造过程中设置初始值，Swift提供两种类型的类构造器来确保所有类实例中的存储属性都能获得初始值
//
//5.1指定构造器和便利构造器
//指定构造器是类中最主要的构造器，将初始化类中所提供的所有属性，每个类至少需要一个指定构造器，便利构造器是辅助型的构造器，可调用同一类中的指定构造器，并为其参数提供默认值
//
//5.2构造器链
//Swift采用三条规则来限制构造器之间的代理调用
//a.指定构造器必须调用其直接父类的指定构造器
//b.便利构造器必须调用同一类中定义的其他构造器
//c.便利构造器最终必须调用一个指定构造器结束
//(指定构造器总是向上代理，便利构造器总是横向代理)
//
//5.3构造器的继承和重载
//Swift中的子类默认不会继承父类的构造器，防止父类的简单构造被子类继承，并错误的创建子类的实例，如果希望子类能继承父类相同的构造器，需要定制子类的构造器
//
//5.4指定构造器和便利构造器的语法

//init(parameters) { //指定构造器
// statements
//}
//// 便利构造器前置 convenience关键字
//convenience init(parameters) {
// statements
//}


class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

let namedMeat = Food(name: "Bacon")
// namedMeat's name is "Bacon"

let mysteryMeat = Food()
// mysteryMeat's name is "[Unnamed]"

class RecipeIngredient: Food {
    var quantity: Int
    init(name: String,quantity: Int) {
        self.quantity = quantity
        super.init(name: name)
    }
    convenience override init(name: String) {
        self.init(name: name,quantity: 1)
    }
}

let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs",quantity: 6)

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

var breakfastList = [
    ShoppingListItem(),ShpingListItem(name: "Bacon"),ShpingListItem(name: "Eggs",quantity: 6),]
//breakfastList[0].name = "Orange juice" breakfastList[0]只读
//breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}
// 1 x orange juice ✔
// 1 x bacon ✘
// 6 x eggs ✘

//与方法、属性和下标不同，在重载构造器时你没有必要使用关键字override。

//如果你重载的构造器是一个指定构造器，你可以在子类里重载它的实现，并在自定义版本的构造器中调用父类版本的构造器。 如果你重载的构造器是一个便利构造器，你的重载过程必须通过调用同一类中提供的其它指定构造器来实现。
//
//自动构造器的继承
//
//如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。
//如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器






//通过闭包和函数来设置属性的默认值
//
//这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。 注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。 如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的self属性，或者调用其它的实例方法。 每当一个新的实例创建时，对应的赋值闭包会执行，

struct Checkerboard {
    let boardColors: [Bool] = {
        var temporaryBoard = [Bool]()
        var isBlack = false
        for i in 1...10 {
            for j in 1...10 {
                temporaryBoard.append(isBlack)
                isBlack = !isBlack
            }
            isBlack = !isBlack
        }
        return temporaryBoard
        }()
    func squareIsBlackAtRow(row: Int,column: Int) -> Bool {
        return boardColors[(row * 10) + column]
    }
}


//析构器,析构器和构造器正好相反,在对象释放的时候调用,使用关键字deinit
class Player {
    var coinsInPurse:Int
    init(coins: Int) {
        print("call init")
        coinsInPurse = coins
    }
    func winCoins(coins: Int) {
        coinsInPurse += 10
    }
    deinit {
        coinsInPurse = 0
    }
}
var playerOne: Player? = Player(coins: 100)
print("coinsInPurse : \(playerOne!.coinsInPurse) coins")


    playerOne = nil //调用deinit
    print("PlayerOne has left the game")