• 作者: Liwx
• 郵箱: 1032282633@qq.com
• 源碼: 需要源碼的同學, 可以在評論區留下您的郵箱

iOS Swift 語法 底層原理 與 內存管理分析 專題：【iOS Swift5語法】

00 - 匯編
01 - 基礎語法
02 - 流程控制
03 - 函數
04 - 枚舉
05 - 可選項
06 - 結構體和類
07 - 閉包
08 - 屬性
09 - 方法
10 - 下標
11 - 繼承
12 - 初始化器init
13 - 可選項

目錄

• 01-初始化器
• 02-初始化器的相互調用
• 03-兩段式初始化
• 04-安全檢查
• 05-重寫
• 06-自動繼承
• 07-required
• 08-屬性觀察器
• 09-可失敗初始化器
• 10-反初始化器(deinit)

01-初始化器

• 類、結構體、枚舉都可以定義初始化器
• 類有2種初始化器: 指定初始化器(designated initializer)、便捷初始化器(convenience initializer)
  • 如果有自定義初始化器, 編譯器 不會為類自動生成無參初始化器(默認初始化器)
  • 每個類至少有一個指定初始化器,指定初始化器是類的主要初始化器
  • 默認初始化器總是類的指定初始化器
  • 類偏向于少量指定初始化器, 一個類通常只有一個指定初始化器

• 初始化器的相互調用規則
  • 指定初始化器必須從它的直系父類調用指定初始化器
  • 便捷初始化器必須從相同的類里調用另一個初始化器
  • 便捷初始化器最終必須調用一個指定初始化器

• 便捷初始化器聲明: 用convenience關鍵字修飾便捷初始化器

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

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

• 如果沒有自定義初始化器, 編譯器會為類自動生成無參初始化器(默認初始化器)

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

• 如果有自定義初始化器, 編譯器 不會為類自動生成無參初始化器(默認初始化器)

class Size {
    var width: Int = 0
    var height: Int = 0
    init(width: Int, height: Int) {    // 編譯器生成這種無參初始化器
        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關鍵字修飾便捷初始化器
  • 便捷初始化器必須從相同的類里調用另一個初始化器
  • 便捷初始化器最終必須調用一個指定初始化器

class Size {
    var width: Int = 0
    var height: Int = 0
    
    init() {
        
    }
    
    convenience init(width: Int, height: Int) {
        // 便捷最終必須調用一個指定初始化器
        self.init()         // 如果沒調用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) // 如果沒調用指定初始化器 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)

• 指定初始化器必須從它的直系父類調用指定初始化器
  • 子類的指定初始化器只能調用直系父類的初始化器
  • 子類指定初始化器不能直接調用本身`的指定初始化器

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

class Student : Person {    // 類繼承冒號左右最好空一格
    var score: Int
    init(age: Int, score: Int) {
        
        // 指定初始化器必須從它的直系父類調用指定初始化器
        self.score = score // 注意: 不能寫到super.init(age: age)之后, 否則報錯 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() {
        
        // 子類的指定初始化器不能直接調用本身的指定初始化器
//        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) // 如果子類自定義初始化器,不會自動繼承直系父類的初始化器,因為這樣會導致父類的存儲屬性為能初始化 error: missing argument for parameter 'score' in call
var stu2 = Student(age: 10, score: 20)

02-初始化器的相互調用

• 初始化器的相互調用規則
  • 指定初始化器必須從它的直系父類調用指定初始化器
  • 便捷初始化器必須從相同的類里調用另一個初始化器
• 便捷初始化器最終必須調用一個指定初始化器

• 這套規則保證了 使用任意初始化器,都可以完整地初始化實例
  • 總結: 指定構造器縱向調用,便捷初始化器橫向調用

QQ20200510-191425@2x.png

03-兩段式初始化

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

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

class Student : Person {
    var score: Int
    init(age: Int, score: Int) {
        
        // 存儲屬性未完成初始化指針,不能用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)
        // 此次可以個性化定制
    }
    
    init() {
        self.score = 0
        super.init(age: 0)
        // 此次可以個性化定制
        self.test()
    }
    
    func test() {
        print("age: \(age), score: \(score)")
    }
}

04-安全檢查

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

QQ20200510-201532@2x.png

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

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階段初始化完成之前`,`不能調用任何實例方法`、`不能讀取任何實例屬性的值`,也`不能引用self`
        super.init(age: 0)
        // `指定初始化器`必須`先調用父類指定初始化器`,然后才能為`繼承的屬性設置新值`
        self.age = 10   // age是從父類繼承的屬性
        self.test()
    }
    
    convenience init(score: Int) {
        self.init(age: 0, score: score)
        // `便捷初始化器`必須先調用`同類中的其它初始化器`,然后再為`任意屬性設置新值`
        self.age = 10
        self.score = 20
    }
    
    func test() {
        print("test")
    }
}

05-重寫

• 當重寫父類的指定初始化器時,必須加上override (即使子類的實現是便捷初始化器)
  • 如果子類寫了一個匹配父類便捷初始化器的初始化器,不用加上override
  • 因為父類的便捷初始化器永遠不會通過子類直接調用,因此,嚴格來說,子類無法重寫父類的便捷初始化器

class Person {
    var age: Int = 0
    init(age: Int) {
        self.age = age
    }
    
    // 因為父類的便捷初始化器永遠不會通過子類直接調用,因此,嚴格來說,子類無法重寫父類的便捷初始化器
    convenience init() {
        self.init(age: 0)
    }
}

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

06-自動繼承

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

• 1.如果子類沒有自定義任何指定初始化器,它會自動繼承父類所有的指定初始化器

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

• 如果子類重寫了父類的指定初始化器,不會在自動繼承父類的初始化器

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) // 如果子類重寫了初始化器,不會在自動繼承父類的初始化器 error: argument passed to call that takes no arguments

• 子類新增自定義便捷初始化器,如果子類沒有重寫父類初始化器,子類可以調用自動繼承父類的初始化器

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 // 參數必須初始化值,才能保證父類繼承下來的初始化器能保證所有存儲屬性都設置了初始值
    convenience init(no: Int) {
        
//        self.no = no    // no存儲屬性未完成初始化, 不能調用self error: 'self' used before 'self.init' call or assignment to 'self'
        self.init(age: 0, name: "")
        // 所有存儲已經初始化完成,可以個性化定制參數
        self.no = no
    }
}

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

• 2.如果子類提供了父類所有指定初始化器的實現(要么通過方式1繼承，要么重寫)
  • 子類自動繼承所有的父類便捷初始化器

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.如果子類提供了父類所有指定初始化器的實現(要么通過方式1繼承，要么重寫)
    // `子類自動繼承所有`的`父類便捷初始化器`
    
    // 子類重寫父類所有指定初始化器
    override init(age: Int, name: String) {
        super.init(age: age, name: name)
    }
    
    override init() {
        super.init()
    }
}

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

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

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.子類以便捷初始化器的形式重寫 父類的所有指定初始化器, 會自動繼承父類的所有便捷初始化器

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)
    }
    
    // 子類以便捷初始化器的形式重寫父類的所有指定初始化器, 會自動繼承父類的所有便捷初始化器
    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修飾初始化器,表明其所有子類都必須實現該初始化器(通過繼承或者重寫實現)
• 如果子類重寫了required初始化器,也必須加上required ,不用加override

• 通過自動繼承方式, 會自動繼承required修飾的指定初始化器

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

class Student : Person {
    
}

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

• 子類新增指定初始化器,必須實現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()方法,沒有重寫父類的指定初始化器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-屬性觀察器

• 父類的屬性在它自己的初始化器中賦值不會觸發屬性觀察器,但在子類的初始化器中賦值會觸發屬性觀察器
• 父類的屬性在它自己的初始化器中賦值`不會觸發屬性觀察器

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

• 在子類的初始化器中賦值會觸發屬性觀察器`

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

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

• 子類和父類都實現父類存儲屬性的屬性觀察器, 則子類初始化器中對父類存儲屬性賦值時,子類和父類的屬性觀察器都會調用

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

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

09-可失敗初始化器

• 類、結構體、枚舉都可以使用init?定義可失敗初始化器
• 不允許同時定義參數標簽、參數個數、參數類型相同的可失敗初始化器和非可失敗初始化器
• 可以用init!定義隱式解包的可失敗初始化器
• 可失敗初始化器可以調用非可失敗初始化器,非可失敗初始化器調用可失敗初始化器需要進行解包
• 如果初始化器調用一個可失敗初始化器導致初始化失敗,那么整個初始化過程都失敗,并且之后的代碼都停止執行
• 可以用一個非可失敗初始化器重寫一個可失敗初始化器,但反過來是不行的

class Person {
    var name: String
    init?(name: String) {   // 可選項初始化器 在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

• 不允許同時定義參數標簽、參數個數、參數類型相同的可失敗初始化器和非可失敗初始化器

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

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

class Person {
    var name: String
    init!(name: String) {   // 可選項初始化器 在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)

• 可失敗初始化器可以調用非可失敗初始化器

class Person {
    var name: String
    convenience init?(name: String) {
        // 可失敗初始化器可以調用非可失敗初始化器
        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)

• 非可失敗初始化器調用可失敗初始化器需要進行解包(慎用)
• 這種情況調用,如果可失敗初始化器返回nil, 強制解包運行時會崩潰

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

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

• 如果初始化器調用一個可失敗初始化器導致初始化失敗,那么整個初始化過程都失敗,并且之后的代碼都停止執行

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

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

• 可以用一個非可失敗初始化器 重寫一個可失敗初始化器,但反過來是不行的

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

class Student : Person {
    // 可以用一個`非可失敗初始化器` `重寫`一個`可失敗初始化器`
    override init(name: String) {
        // 因為沒有調用super,所以報錯 error: 'super.init' isn't called on all paths before returning from initializer
    }
}

• 不可以用一個可失敗初始化器 重寫一個非可失敗初始化器

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

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

10-反初始化器(deinit)

• deinit叫做反初始化器,類似于C++的析構函數、OC中的dealloc方法
• 當類的實例對象被釋放內存時,就會調用實例對象的deinit方法
• 結構體和枚舉是不能使用deinit

class Person {
    deinit {
        print("Person deinit")  // 實例對象被釋放會調用deinit
    }
}
func test() {
    var p1 = Person()
}
print("1")  // 1
test()      // Person deinit
print("2")  // 2

• deinit不接受任何參數,不能寫小括號,不能自行調用
• 父類的deinit能被子類繼承
• 子類的deinit實現執行完畢后會調用父類的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 語法 底層原理 與 內存管理分析 專題：【iOS Swift5語法】

下一篇: 敬請期待
上一篇: 11 - 繼承