Swift 初始化

初始化函数

import UIKit

// 初始化函数
struct Fahrenheit {
    var temperature: Double
    init () {
        temperature = 32.0
    }
}

var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")

struct Celsius {
    var temperatureInCelsius: Double
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
    
    init(celisus: Double) {
        temperatureInCelsius = celisus
    }
}

let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
print("boilingPointOfWater temperatureInCelsius value is \(boilingPointOfWater.temperatureInCelsius)")

let freezingPointOfWater = Celsius(fromKelvin: 273.15)
print("freezingPointOfWater temperatureInCelsius value is \(freezingPointOfWater.temperatureInCelsius)")

let bodyTemperature = Celsius(celisus: 37.0)
print("bodyTemperature temperatureInCelsius value is \(bodyTemperature.temperatureInCelsius)")

// 可选属性
class SurveyQuestion {
    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()
cheeseQuestion.response = "Yes, I do like cheese."

// 初始化时赋值常量属性
class AnotherSurveyQuestion {
    let text: String
    var response: String?
    init(text: String) {
        self.text = text
    }
    
    func ask() {
        print(text)
    }
}

let anotherCheeseQuestion = AnotherSurveyQuestion(text: "Do you like cheese?")

// 值类型的初始化
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.0)
        let originY = center.y - (size.height / 2.0)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
    
}

let basicRect = Rect()
let originRect = Rect(origin: Point(x: 2.0, y: 2.0), size: Size(width: 5.0, height: 5.0))
let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))
print("basicRect's origin is (\(basicRect.origin.x), \(basicRect.origin.y)) and its size is (\(basicRect.size.width), \(basicRect.size.height))")
print("originRect origin is (\(originRect.origin.x), \(originRect.origin.y)) and its size is (\(originRect.size.width), \(originRect.size.height))")
print("centerRect origin is (\(centerRect.origin.x), \(centerRect.origin.y)) and its size is (\(centerRect.size.width), \(centerRect.size.height))")

console log 如下

初始化函数.png

类的指定初始化函数和便利初始化函数

// 类的指定初始化函数和便利初始化函数
class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    
    convenience init()
    {
        self.init(name: "[Unnamed]")
    }
}

let nameMeat = Food(name: "Bacon")
print("nameMeat's name is \(nameMeat.name)")

let mysteryMeat = Food()
print("mysteryMeat's name is \(mysteryMeat.name)")

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

let oneMysteryItem = RecipeIngredient()
print("oneMysteryItem's name is \(oneMysteryItem.name) and quantity is \(oneMysteryItem.quantity)")

let oneBacon = RecipeIngredient(name: "Bacon")
print("oneBacon's name is \(oneBacon.name) and quantity is \(oneBacon.quantity)")

let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
print("sixEggs's name is \(sixEggs.name) and quantity is \(sixEggs.quantity)")

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

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

console log 如下

类的指定初始化函数和便利初始化函数.png

注意: 子类指定初始化函数必须调用直接父类的指定初始化函数，便利初始化函数要最终调用指定初始化函数
RecipeIngredient子类与Food父类 分析

RecipeIngredient子类与Food父类.png
可失败的初始化函数

// 结构体 可失败的初始化函数
struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty {
            return nil
        }
        self.species = species
    }
}

let someCreature = Animal(species: "Giraffe")
if let giraffe = someCreature {
    print("An animal was initialized with a species of \(giraffe.species)")
}

let anonymousCreature = Animal(species: "")
if anonymousCreature == nil {
    print("The anonymous creature could not be initialized")
}

// 枚举 可失败的初始化函数
enum TemperatureUnit {
    case kelvin, celsius, fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .kelvin
        case "C":
            self = .celsius
        case "F":
            self = .fahrenheit
        default:
            return nil
        }
    }
}

let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
    print("This is a defined temperature unit, so initialization succeeded.")
}

let unkownUnit = TemperatureUnit(symbol: "X")
if unkownUnit == nil {
    print("This is not a defined temperature unit, so initialization failed.")
}

// 枚举值raw value 可失败的初始化函数
enum AnotherTemperatureUnit: Character {
    case kelvin = "K", celisus = "C", fahrenheit = "F"
}

let anotherFahrenheitUnit = AnotherTemperatureUnit(rawValue: "F")
if anotherFahrenheitUnit != nil {
    print("This is a defined temperature unit, so initialization succeeded.")
}

let anotherUnkownUnit = AnotherTemperatureUnit(rawValue: "X")
if anotherUnkownUnit == nil {
    print("This is not a defined temperature unit, so initialization failed.")
}

// 类的可失败初始化函数
class Product {
    let name: String
    init?(name: String)
    {
        if name.isEmpty {
            return nil
        }
        
        self.name = name
    }
}

class CarItem: Product {
    let quantity: Int
    init?(name: String, quantity: Int) {
        if  quantity < 1 {
            return nil
        }
        
        self.quantity = quantity
        super.init(name: name)
    }
}

if let twoSocks = CarItem(name: "sock", quantity: 2) {
    print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}

if let zeroShirts = CarItem(name: "shirt", quantity: 0) {
    print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
    print("Unable to initialize zero shirts")
}

if let oneUnnamed = CarItem(name: "", quantity: 1) {
    print("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
} else {
    print("Unable to initialize one unnamed product")
}

// 子类重写可失败的初始化函数
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()
        if name.isEmpty {
            self.name = "Untitled"
        } else {
            self.name = name
        }
    }
}

let oneDocument = AutomaticallyNamedDocument(name: "")
print(oneDocument.name!)

console log 如下

可失败的初始化函数.png

通过闭包或者函数设置属性值

// 通过闭包或者函数设置属性值
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 {
        return boardColors[(row * 8) + column]
    }
}

let board = Chessboard()
print(board.squareIsBlackAt(0, column: 1))
print(board.squareIsBlackAt(7, column: 7))

console log 如下

通过闭包或者函数设置属性值.png