日韩有码第一页,亚洲日韩内射,9999蜜臀

作者: Liwx
郵箱: 1032282633@qq.com
源碼: 需要源碼的同學(xué), 可以在評(píng)論區(qū)留下您的郵箱

iOS Swift 語(yǔ)法 底層原理 與 內(nèi)存管理分析專題：【iOS Swift5語(yǔ)法】

00 - 匯編
 01 - 基礎(chǔ)語(yǔ)法
 02 - 流程控制
 03 - 函數(shù)
04 - 枚舉
 05 - 可選項(xiàng)
06 - 結(jié)構(gòu)體和類
 07 - 閉包
 08 - 屬性
 09 - 方法
 10 - 下標(biāo)
11 - 繼承
 12 - 初始化器init
13 - 可選項(xiàng)

01-初始化器

類、結(jié)構(gòu)體、枚舉都可以定義初始化器
類有2種初始化器: 指定初始化器(designated initializer)、便捷初始化器(convenience initializer)
- 如果有自定義初始化器, 編譯器 不會(huì)為類自動(dòng)生成無(wú)參初始化器(默認(rèn)初始化器)
- 每個(gè)類至少有一個(gè)指定初始化器,指定初始化器是類的主要初始化器
- 默認(rèn)初始化器總是類的指定初始化器
- 類偏向于少量指定初始化器, 一個(gè)類通常只有一個(gè)指定初始化器

初始化器的相互調(diào)用規(guī)則
- 指定初始化器必須從它的直系父類調(diào)用指定初始化器
- 便捷初始化器必須從相同的類里調(diào)用另一個(gè)初始化器
- 便捷初始化器最終必須調(diào)用一個(gè)指定初始化器

便捷初始化器聲明: 用convenience關(guān)鍵字修飾便捷初始化器

// 指定初始化器
init(parameters) {
    statements
}

// 便捷初始化器
convenience init(parameters) {
    statements
}

如果沒(méi)有自定義初始化器, 編譯器會(huì)為類自動(dòng)生成無(wú)參初始化器(默認(rèn)初始化器)

class Size {
    var width: Int = 0
    var height: Int = 0
//    init() {    // 編譯器生成這種無(wú)參初始化器
//
//    }
}
var size = Size()

如果有自定義初始化器, 編譯器 不會(huì)為類自動(dòng)生成無(wú)參初始化器(默認(rèn)初始化器)

class Size {
    var width: Int = 0
    var height: Int = 0
    init(width: Int, height: Int) {    // 編譯器生成這種無(wú)參初始化器
        self.width = width
        self.height = height
    }
}
//var size = Size()   // error: missing arguments for parameters 'width', 'height' in call
var size = Size(width: 10, height: 20)

便捷初始化器聲明: 用convenience關(guān)鍵字修飾便捷初始化器
- 便捷初始化器必須從相同的類里調(diào)用另一個(gè)初始化器
- 便捷初始化器最終必須調(diào)用一個(gè)指定初始化器

class Size {
    var width: Int = 0
    var height: Int = 0
    
    init() {
        
    }
    
    convenience init(width: Int, height: Int) {
        // 便捷最終必須調(diào)用一個(gè)指定初始化器
        self.init()         // 如果沒(méi)調(diào)用self.init(), error: 'self' used before 'self.init' call or assignment to 'self'
        self.width = width
        self.height = height
    }
}
var s1 = Size()
var s2 = Size(width: 10, height: 10)

指定初始化器

class Size {
    var width: Int = 0
    var height: Int = 0
    
    // 指定初始化器(主要初始化器)
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
    
    convenience init(width: Int) {
        self.init(width: width, height: 0) // 如果沒(méi)調(diào)用指定初始化器 error: 'self' used before 'self.init' call or assignment to 'self'
        self.width = width
    }
    
    convenience init(height: Int) {
        self.init(width: 0, height: height)
        self.height = height
    }
    
    convenience init() {
        self.init(width: 0, height: 0)
    }
}
var s1 = Size()
var s2 = Size(width: 10, height: 10)
var s3 = Size(width: 10)
var s4 = Size(height: 20)

指定初始化器必須從它的直系父類調(diào)用指定初始化器
- 子類的指定初始化器只能調(diào)用直系父類的初始化器
- 子類指定初始化器不能直接調(diào)用本身`的指定初始化器

class Person {
    var age: Int = 0
    init(age: Int) {
        self.age = age
    }
    
    convenience init() {
        self.init(age: 0)
    }
}

class Student : Person {    // 類繼承冒號(hào)左右最好空一格
    var score: Int
    init(age: Int, score: Int) {
        
        // 指定初始化器必須從它的直系父類調(diào)用指定初始化器
        self.score = score // 注意: 不能寫到super.init(age: age)之后, 否則報(bào)錯(cuò) error: property 'self.score' not initialized at super.init call
        super.init(age: age)
        
        // error: 'super.init' isn't called on all paths before returning from initializer
//        self.age = age
//        self.score = score
    }
    
    
    init() {
        
        // 子類的指定初始化器不能直接調(diào)用本身的指定初始化器
//        self.init(age: 0, score: 0) // error: designated initializer for 'Student' cannot delegate (with 'self.init'); did you mean this to be a convenience initializer?
        
        self.score = 0
        super.init(age: 0)
    }
}

//var stu1 = Student(age: 10) // 如果子類自定義初始化器,不會(huì)自動(dòng)繼承直系父類的初始化器,因?yàn)檫@樣會(huì)導(dǎo)致父類的存儲(chǔ)屬性為能初始化 error: missing argument for parameter 'score' in call
var stu2 = Student(age: 10, score: 20)

02-初始化器的相互調(diào)用

初始化器的相互調(diào)用規(guī)則
- 指定初始化器必須從它的直系父類調(diào)用指定初始化器
- 便捷初始化器必須從相同的類里調(diào)用另一個(gè)初始化器
便捷初始化器最終必須調(diào)用一個(gè)指定初始化器

這套規(guī)則保證了使用任意初始化器,都可以完整地初始化實(shí)例
- 總結(jié): 指定構(gòu)造器縱向調(diào)用,便捷初始化器橫向調(diào)用

QQ20200510-191425@2x.png

03-兩段式初始化

Swift在編碼安全方面是煞費(fèi)苦心,為了保證初始化過(guò)程的安全,設(shè)定了兩段式初始化、安全檢查
兩段式初始化
- 第1階段:初始化所有存儲(chǔ)屬性(向上調(diào)用)
  1.外層調(diào)用指定\便捷初始化器
  2.分配內(nèi)存給實(shí)例,但未初始化
  3.指定初始化器確保當(dāng)前類定義的存儲(chǔ)屬性都初始化
  4.指定初始化器調(diào)用父類的指定初始化器，不斷向上調(diào)用,形成初始化器鏈
- 第2階段:設(shè)置新的存儲(chǔ)屬性值(向下調(diào)用)
  1.從頂部初始化器往下,鏈中的每一個(gè)指定初始化器都有機(jī)會(huì)進(jìn)一步定制實(shí)例
  2.初始化器現(xiàn)在能夠使用self (訪問(wèn)、修改它的屬性,調(diào)用它的實(shí)例方法等等)
  3.最終,鏈中任何便捷初始化器都有機(jī)會(huì)定制實(shí)例以及使用self

class Person {
    var age: Int = 0
    init(age: Int) {
        self.age = age
        // 此次可以個(gè)性化定制
    }
    
    convenience init() {
        self.init(age: 0)
        // 此次可以個(gè)性化定制
    }
}

class Student : Person {
    var score: Int
    init(age: Int, score: Int) {
        
        // 存儲(chǔ)屬性未完成初始化指針,不能用self
//        print(self) // error: 'self' used before 'super.init' call
//        self.age = 10   // error: 'self' used in property access 'age' before 'super.init' call
//        self.test() // error: 'self' used in method call 'test' before 'super.init' call
//        var fn = {  // error'self' captured by a closure before all members were initialized
//            self.age = 20
//        }
//        fn()
        
        self.score = score
        super.init(age: age)
        // 此次可以個(gè)性化定制
    }
    
    init() {
        self.score = 0
        super.init(age: 0)
        // 此次可以個(gè)性化定制
        self.test()
    }
    
    func test() {
        print("age: \(age), score: \(score)")
    }
}

04-安全檢查

指定初始化器必須保證在調(diào)用父類初始化器之前,其所在類定義的所有存儲(chǔ)屬性都要初始化完成
指定初始化器必須先調(diào)用父類指定初始化器,然后才能為繼承的屬性設(shè)置新值
便捷初始化器必須先調(diào)用同類中的其它初始化器,然后再為任意屬性設(shè)置新值
初始化器在第1階段初始化完成之前,不能調(diào)用任何實(shí)例方法、不能讀取任何實(shí)例屬性的值,也不能引用self
直到第1階段結(jié)束,實(shí)例才算完全合法

QQ20200510-201532@2x.png

class Person {
    var age: Int = 0
    init(age: Int) {
        self.age = age
        // 此次可以個(gè)性化定制
    }
    
    convenience init() {
        self.init(age: 0)
        // 此次可以個(gè)性化定制
    }
}

class Student : Person {
    var score: Int
    init(age: Int, score: Int) {
        self.score = score
        super.init(age: age)
    }
    
    init() {
        self.score = 0
//        self.age = 20   // 初始化器在`第1階段初始化完成之前`,`不能調(diào)用任何實(shí)例方法`、`不能讀取任何實(shí)例屬性的值`,也`不能引用self`
        super.init(age: 0)
        // `指定初始化器`必須`先調(diào)用父類指定初始化器`,然后才能為`繼承的屬性設(shè)置新值`
        self.age = 10   // age是從父類繼承的屬性
        self.test()
    }
    
    convenience init(score: Int) {
        self.init(age: 0, score: score)
        // `便捷初始化器`必須先調(diào)用`同類中的其它初始化器`,然后再為`任意屬性設(shè)置新值`
        self.age = 10
        self.score = 20
    }
    
    func test() {
        print("test")
    }
}

05-重寫

當(dāng)重寫父類的指定初始化器時(shí),必須加上override (即使子類的實(shí)現(xiàn)是便捷初始化器)
- 如果子類寫了一個(gè)匹配父類便捷初始化器的初始化器,不用加上override
- 因?yàn)?code>父類的便捷初始化器永遠(yuǎn)不會(huì)通過(guò)子類直接調(diào)用,因此,嚴(yán)格來(lái)說(shuō),子類無(wú)法重寫父類的便捷初始化器

class Person {
    var age: Int = 0
    init(age: Int) {
        self.age = age
    }
    
    // 因?yàn)楦割惖谋憬莩跏蓟饔肋h(yuǎn)不會(huì)通過(guò)子類直接調(diào)用,因此,嚴(yán)格來(lái)說(shuō),子類無(wú)法重寫父類的便捷初始化器
    convenience init() {
        self.init(age: 0)
    }
}

class Student : Person {
    var score: Int
    
    init(age: Int, score: Int) {
        self.score = score
        super.init(age: age)
    }
    
    // 當(dāng)`重寫父類的指定初始化器`時(shí),必須加上`override` (`即使子類的實(shí)現(xiàn)是便捷初始化器`)
    // 重寫為指定初始化器
//    override init(age: Int) {
//        self.score = 0
//        super.init(age: age)
//    }
    
    // 重寫為便捷初始化器
//    override convenience init(age: Int) {
//        self.init(age: age, score: 0)
//
//    }
    
    // 如果`子類`寫了一個(gè)`匹配父類便捷初始化器`的初始化器,`不用加上override`
    // 子類寫了匹配父類的便捷初始化器的指定初始化器(不算重寫, 重寫表示調(diào)用super.init())
//    init() {
//        self.score = 0
//        super.init(age: 0)
//    }
    
    // 子類寫了匹配父類的便捷初始化器的便捷初始化器(不算重寫, 重寫表示調(diào)用super.init())
    convenience init() {
        self.init(age: 0, score: 0)
    }
    
}

06-自動(dòng)繼承

1.如果子類沒(méi)有自定義任何指定初始化器,它會(huì)自動(dòng)繼承 父類所有的指定初始化器
2.如果子類提供了父類所有指定初始化器的實(shí)現(xiàn)(要么通過(guò)方式1繼承，要么重寫)
- 子類自動(dòng)繼承所有的父類便捷初始化器
3.就算子類添加了更多的便捷初始化器,這些規(guī)則仍然適用
4.子類以便捷初始化器的形式重寫父類的指定初始化器,也可以作為滿足規(guī)則2的一部分

1.如果子類沒(méi)有自定義任何指定初始化器,它會(huì)自動(dòng)繼承父類所有的指定初始化器

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init(age: Int) {
        self.age = age
        self.name = ""
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
}

class Student : Person {
    
}

var stu1 = Student(age: 10)
var stu2 = Student(age: 10, name: "Liwx")

如果子類重寫了父類的指定初始化器,不會(huì)在自動(dòng)繼承父類的初始化器

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init(age: Int) {
        self.age = age
        self.name = ""
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
}

class Student : Person {
    override init() {
        super.init()
    }
}
var stu1 = Student()
//var stu2 = Student(age: 10) // 如果子類重寫了初始化器,不會(huì)在自動(dòng)繼承父類的初始化器 error: argument passed to call that takes no arguments

子類新增自定義便捷初始化器,如果子類沒(méi)有重寫父類初始化器,子類可以調(diào)用自動(dòng)繼承父類的初始化器

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init(age: Int) {
        self.age = age
        self.name = ""
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
}

class Student : Person {
    
    var no: Int = 0 // 參數(shù)必須初始化值,才能保證父類繼承下來(lái)的初始化器能保證所有存儲(chǔ)屬性都設(shè)置了初始值
    convenience init(no: Int) {
        
//        self.no = no    // no存儲(chǔ)屬性未完成初始化, 不能調(diào)用self error: 'self' used before 'self.init' call or assignment to 'self'
        self.init(age: 0, name: "")
        // 所有存儲(chǔ)已經(jīng)初始化完成,可以個(gè)性化定制參數(shù)
        self.no = no
    }
}

var stu1 = Student()
var stu2 = Student(age: 10)
var stu3 = Student(age: 10, name: "Liwx")
var stu4 = Student(no: 20)

2.如果子類提供了父類所有指定初始化器的實(shí)現(xiàn)(要么通過(guò)方式1繼承，要么重寫)
- 子類自動(dòng)繼承所有的父類便捷初始化器

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
    
    convenience init(age: Int) {
        self.init(age: age, name: "")
    }
    
    convenience init(name: String) {
        self.init(age: 0, name: name)
    }
}

class Student : Person {
    
    // 2.如果子類提供了父類所有指定初始化器的實(shí)現(xiàn)(要么通過(guò)方式1繼承，要么重寫)
    // `子類自動(dòng)繼承所有`的`父類便捷初始化器`
    
    // 子類重寫父類所有指定初始化器
    override init(age: Int, name: String) {
        super.init(age: age, name: name)
    }
    
    override init() {
        super.init()
    }
}

var stu1 = Student(age: 10, name: "Liwx")   // 子類提供了父類所有指定初始化器的實(shí)現(xiàn),`子類自動(dòng)繼承所有`的`父類便捷初始化器`
var stu2 = Student()
var stu3 = Student(age: 10)
var stu4 = Student(name: "Liwx")

3.就算子類添加了更多的便捷初始化器,這些規(guī)則仍然適用

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
    
    convenience init(age: Int) {
        self.init(age: age, name: "")
    }
    
    convenience init(name: String) {
        self.init(age: 0, name: name)
    }
}

class Student : Person {
    convenience init(age: Int, name: String, no: Int) {
        self.init(age: age, name: name)
    }
}

4.子類以便捷初始化器的形式重寫 父類的所有指定初始化器, 會(huì)自動(dòng)繼承父類的所有便捷初始化器

class Person {
    var age: Int = 0
    var name: String
    
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    
    init() {
        self.age = 0
        self.name = ""
    }
    
    convenience init(age: Int) {
        self.init(age: age, name: "")
    }
    
    convenience init(name: String) {
        self.init(age: 0, name: name)
    }
}

class Student : Person {
    
    init(age: Int, name: String, no: Int) {
        super.init(age: age, name: name)
    }
    
    // 子類以便捷初始化器的形式重寫父類的所有指定初始化器, 會(huì)自動(dòng)繼承父類的所有便捷初始化器
    convenience override init(age: Int, name: String) {
        self.init(age: age, name: name)
    }
    
    convenience override init() {
        self.init(age: 0, name: "")
    }
}

var stu1 = Student()
var stu2 = Student(age: 10)
var stu3 = Student(age: 10, name: "Liwx")
var stu4 = Student(age: 10, name: "Liwx", no: 20)
var stu5 = Student(name: "Liwx")

07-required

用required修飾初始化器,表明其所有子類都必須實(shí)現(xiàn)該初始化器(通過(guò)繼承或者重寫實(shí)現(xiàn))
如果子類重寫了required初始化器,也必須加上required ,不用加override

通過(guò)自動(dòng)繼承方式, 會(huì)自動(dòng)繼承required修飾的指定初始化器

class Person {
    required init() { }
    init(age: Int) { }
}

class Student : Person {
    
}

var stu1 = Student()
var stu2 = Student(age: 10)

子類新增指定初始化器,必須實(shí)現(xiàn)required修飾的指定初始化器

class Person {
    required init() { }
    init(age: Int) { }
}

class Student : Person {
    init(no: Int) {
        super.init()
    }
    required init() {
        super.init()
    }
}

var stu1 = Student()
var stu2 = Student(no: 20)
//var stu3 = Student(age: 10) // 子類重寫了父類指定初始化器init()方法,沒(méi)有重寫父類的指定初始化器init(age:), 所以該初始化器不能使用  error: incorrect argument label in call (have 'age:', expected 'no:')

required 修飾便捷初始化器

class Person {
    required convenience init() {
        self.init(age: 0)
    }
    init(age: Int) { }
}

class Student : Person {
    
    init(no: Int) {
        super.init(age: 0)
    }
    
    override init(age: Int) {
        super.init(age: age)
    }
    
    required convenience init() {
        self.init(age: 0)
    }
}

08-屬性觀察器

父類的屬性在它自己的初始化器中賦值不會(huì)觸發(fā)屬性觀察器,但在子類的初始化器中賦值會(huì)觸發(fā)屬性觀察器
父類的屬性在它自己的初始化器中賦值`不會(huì)觸發(fā)屬性觀察器

class Person {
    
    var age: Int {
        willSet {
            print("Person willSet", newValue)
        }
        didSet {
            print("Person didSet", oldValue)
        }
    }
    init() {
        self.age = 0    // 此處不會(huì)調(diào)用自己的屬性觀察器
    }
}
var p1 = Person()   // 此次沒(méi)有打印任何信息

在子類的初始化器中賦值會(huì)觸發(fā)屬性觀察器`

class Person {
    
    var age: Int {
        willSet {
            print("Person willSet", newValue)
        }
        didSet {
            print("Person didSet", oldValue)
        }
    }
    init() {
        self.age = 0    // 此處不會(huì)調(diào)用自己的屬性觀察器
    }
}

class Student : Person {
    override init() {
        super.init()
        self.age = 1    // 此處會(huì)調(diào)用父類的屬性觀察器
    }
}
// Person willSet 1
// Person didSet 0
var stu1 = Student()

子類和父類都實(shí)現(xiàn)父類存儲(chǔ)屬性的屬性觀察器, 則子類初始化器中對(duì)父類存儲(chǔ)屬性賦值時(shí),子類和父類的屬性觀察器都會(huì)調(diào)用

class Person {
    
    var age: Int {
        willSet {
            print("Person willSet", newValue)
        }
        didSet {
            print("Person didSet", oldValue)
        }
    }
    init() {
        self.age = 0    // 此處不會(huì)調(diào)用自己的屬性觀察器
    }
}

class Student : Person {
    
    override var age: Int {
        willSet {
            print("Student willSet", newValue)
        }
        didSet {
            print("Student didSet", oldValue)
        }
    }
    
    override init() {
        super.init()
        self.age = 1    // 此處會(huì)調(diào)用父類的屬性觀察器
    }
}
//Student willSet 1
//Person willSet 1
//Person didSet 0
//Student didSet 0
var stu1 = Student()

09-可失敗初始化器

類、結(jié)構(gòu)體、枚舉都可以使用init?定義可失敗初始化器
不允許同時(shí)定義參數(shù)標(biāo)簽、參數(shù)個(gè)數(shù)、參數(shù)類型相同的可失敗初始化器和非可失敗初始化器
可以用init!定義隱式解包的可失敗初始化器
可失敗初始化器可以調(diào)用非可失敗初始化器,非可失敗初始化器調(diào)用可失敗初始化器需要進(jìn)行解包
如果初始化器調(diào)用一個(gè)可失敗初始化器導(dǎo)致初始化失敗,那么整個(gè)初始化過(guò)程都失敗,并且之后的代碼都停止執(zhí)行
可以用一個(gè)非可失敗初始化器重寫一個(gè)可失敗初始化器,但反過(guò)來(lái)是不行的

class Person {
    var name: String
    init?(name: String) {   // 可選項(xiàng)初始化器 在init后面加上?
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

var p1 = Person(name: "")
print(p1)   // nil

var p2 = Person(name: "Liwx")
print(p2)   // Optional(__lldb_expr_2.Person)

Int可失敗初始化器使用

// Int可失敗初始化器定義
// public Init?(_ description: String)
var num1 = Int("123")
print(num1) // Optional(123)
var num2 = Int("abc")
print(num2) // nil

枚舉可失敗初始化器使用

enum Answer : Int {
    case wrong, right
}

var answer1 = Answer(rawValue: 1)
print(answer1)  // Optional(__lldb_expr_13.Answer.right)
var answer2 = Answer(rawValue: 100)
print(answer2)  // nil

不允許同時(shí)定義參數(shù)標(biāo)簽、參數(shù)個(gè)數(shù)、參數(shù)類型相同的可失敗初始化器和非可失敗初始化器

class Person {
    var name: String
    init?(name: String) {   // 可選項(xiàng)初始化器 在init后面加上?
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
    // 不允許同時(shí)定義參數(shù)標(biāo)簽、參數(shù)個(gè)數(shù)、參數(shù)類型相同的可失敗初始化器和非可失敗初始化器
//    init(name: String) {    // error: invalid redeclaration of 'init(name:)'
//        self.name = name
//    }
}

可以用init!定義隱式解包的可失敗初始化器

class Person {
    var name: String
    init!(name: String) {   // 可選項(xiàng)初始化器 在init后面加上?
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

var p1 = Person(name: "")
print(p1)   // nil

var p2 = Person(name: "Liwx")
print(p2)   // Optional(__lldb_expr_16.Person)

可失敗初始化器可以調(diào)用非可失敗初始化器

class Person {
    var name: String
    convenience init?(name: String) {
        // 可失敗初始化器可以調(diào)用非可失敗初始化器
        self.init()
        
        if name.isEmpty {
            return nil
        }
    }
    
    init() {
        self.name = ""
    }
}

var p1 = Person(name: "")
print(p1)   // nil
var p2 = Person(name: "Liwx")
print(p2)   // Optional(__lldb_expr_19.Person)

非可失敗初始化器調(diào)用可失敗初始化器需要進(jìn)行解包(慎用)
這種情況調(diào)用,如果可失敗初始化器返回nil, 強(qiáng)制解包運(yùn)行時(shí)會(huì)崩潰

class Person {
    var name: String
    
    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }

    convenience init() {
        // 非可失敗初始化器調(diào)用可失敗初始化器需要進(jìn)行解包
        self.init(name: "")!
    }
    
    // 這樣也可以
//    init!(name: String) {
//        if name.isEmpty {
//            return nil
//        }
//        self.name = name
//    }
//
//    convenience init() {
//        // 非可失敗初始化器調(diào)用可失敗初始化器需要進(jìn)行解包
//        self.init(name: "")
//    }
}
var p1 = Person()
print(p1)   // error: Unexpectedly found nil while unwrapping an Optional value

如果初始化器調(diào)用一個(gè)可失敗初始化器導(dǎo)致初始化失敗,那么整個(gè)初始化過(guò)程都失敗,并且之后的代碼都停止執(zhí)行

class Person {
    var name: String
    
    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }

    convenience init?() {
        // 非可失敗初始化器調(diào)用可失敗初始化器需要進(jìn)行解包
        self.init(name: "")
        // 可失敗初始化器如果初始化失敗,以下代碼不執(zhí)行
        self.name = "Liwx"
        print("test")   // 不會(huì)打印test
    }
}
var p1 = Person()
print(p1)   // nil

可以用一個(gè)非可失敗初始化器 重寫一個(gè)可失敗初始化器,但反過(guò)來(lái)是不行的

class Person {
    var name: String
    
    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

class Student : Person {
    // 可以用一個(gè)`非可失敗初始化器` `重寫`一個(gè)`可失敗初始化器`
    override init(name: String) {
        // 因?yàn)闆](méi)有調(diào)用super,所以報(bào)錯(cuò) error: 'super.init' isn't called on all paths before returning from initializer
    }
}

不可以用一個(gè)可失敗初始化器 重寫一個(gè)非可失敗初始化器

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

class Student : Person {
    // 不可以用一個(gè)`可失敗初始化器` `重寫`一個(gè)`非可失敗初始化器`
    // error: failable initializer 'init(name:)' cannot override a non-failable initializer
    override init?(name: String) {
        super.init(name: name)
    }
}

10-反初始化器(deinit)

deinit叫做反初始化器,類似于C++的析構(gòu)函數(shù)、OC中的dealloc方法
當(dāng)類的實(shí)例對(duì)象被釋放內(nèi)存時(shí),就會(huì)調(diào)用實(shí)例對(duì)象的deinit方法
結(jié)構(gòu)體和枚舉是不能使用deinit

class Person {
    deinit {
        print("Person deinit")  // 實(shí)例對(duì)象被釋放會(huì)調(diào)用deinit
    }
}
func test() {
    var p1 = Person()
}
print("1")  // 1
test()      // Person deinit
print("2")  // 2

deinit不接受任何參數(shù),不能寫小括號(hào),不能自行調(diào)用
父類的deinit能被子類繼承
子類的deinit實(shí)現(xiàn)執(zhí)行完畢后會(huì)調(diào)用父類的deinit

class Person {
    deinit {
        print("Person deinit")
    }
}

class Student : Person {
    deinit {
        print("Student deinit")
    }
}
func test() {
    var stu1 = Student()
}

// 1
// Student deinit
// Person deinit
// 2
print("1")
test()
print("2")

iOS Swift 語(yǔ)法 底層原理 與 內(nèi)存管理分析專題：【iOS Swift5語(yǔ)法】

下一篇: 敬請(qǐng)期待
上一篇: 11 - 繼承

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Swift語(yǔ)法 Swift5 【12 - 初始化器init】

Swift語(yǔ)法 Swift5 【12 - 初始化器init】

目錄

01-初始化器

02-初始化器的相互調(diào)用

03-兩段式初始化

04-安全檢查

05-重寫

06-自動(dòng)繼承

07-required

08-屬性觀察器

09-可失敗初始化器

10-反初始化器(deinit)

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Swift語(yǔ)法 Swift5 【12 - 初始化器init】

目錄

01-初始化器

02-初始化器的相互調(diào)用

03-兩段式初始化

04-安全檢查

05-重寫

06-自動(dòng)繼承

07-required

08-屬性觀察器

09-可失敗初始化器

10-反初始化器(deinit)

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av