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
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • Swift 初始化（Initialization）
    初始化（Initialization） 初始化是类、结构体、枚举类型的准备过程。这个过程涉及到所有存储属性的初始化...
    泗哥阅读 10,940评论 0赞 3
  • Swift2.1-初始化
    官方文档 初始化 Initialization是为准备使用类，结构体或者枚举实例的一个过程。这个过程涉及了在实例里...
    hrscy阅读 4,834评论 0赞 1
  • Swift 初始化 init 小结
    Swift 的初始化和 Objective-C 有一个很大的不同，Objective-C 默认会给每个属性赋一个空...
    yanging阅读 10,703评论 0赞 8
  • 从 Swift 初始化说起
    原文地址：http://huizhao.win/2016/11/13/swift-init/ 从 Objectiv...
    赵大老板阅读 34,939评论 11赞 121
  • swift - 初始化
    // 同于 Objective-C 的初始化器，Swift 初始化器不返回值 初始化器 默认的属性值 自定义初始化...
    风___________阅读 3,068评论 0赞 0

友情链接更多精彩内容