- 作者: Liwx
- 郵箱: 1032282633@qq.com
- 源碼: 需要
源碼的同學(xué), 可以在評論區(qū)留下您的郵箱
iOS Swift 語法
底層原理與內(nèi)存管理分析 專題：【iOS Swift5語法】00 - 匯編
01 - 基礎(chǔ)語法
02 - 流程控制
03 - 函數(shù)
04 - 枚舉
05 - 可選項(xiàng)
06 - 結(jié)構(gòu)體和類
07 - 閉包
08 - 屬性
09 - 方法
10 - 下標(biāo)
11 - 繼承
12 - 初始化器init
13 - 可選項(xiàng)
目錄
- 01-初始化器
- 02-初始化器的相互調(diào)用
- 03-兩段式初始化
- 04-安全檢查
- 05-重寫
- 06-自動(dòng)繼承
- 07-required
- 08-屬性觀察器
- 09-可失敗初始化器
- 10-反初始化器(deinit)
01-初始化器
-
類肪笋、結(jié)構(gòu)體墙懂、枚舉都可以定義初始化器 -
類有2種初始化器:指定初始化器(designated initializer)、便捷初始化器(convenience initializer)- 如果
有自定義初始化器,編譯器不會(huì)為類自動(dòng)生成無參初始化器(默認(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
}
- 如果
沒有自定義初始化器,編譯器會(huì)為類自動(dòng)生成無參初始化器(默認(rèn)初始化器)
class Size {
var width: Int = 0
var height: Int = 0
// init() { // 編譯器生成這種無參初始化器
//
// }
}
var size = Size()
- 如果
有自定義初始化器,編譯器不會(huì)為類自動(dòng)生成無參初始化器(默認(rèn)初始化器)
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關(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() // 如果沒調(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) // 如果沒調(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 { // 類繼承冒號左右最好空一格
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)用
- 總結(jié):
QQ20200510-191425@2x.png
03-兩段式初始化
- Swift在編碼安全方面是煞費(fèi)苦心,為了
保證初始化過程的安全,設(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(訪問哀峻、修改它的屬性,調(diào)用它的實(shí)例方法等等)
3.最終,鏈中任何便捷初始化器都有機(jī)會(huì)定制實(shí)例以及使用self
- 第1階段:
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ì)通過子類直接調(diào)用,因此,嚴(yán)格來說,子類無法重寫父類的便捷初始化器
- 如果
class Person {
var age: Int = 0
init(age: Int) {
self.age = age
}
// 因?yàn)楦割惖谋憬莩跏蓟饔肋h(yuǎn)不會(huì)通過子類直接調(diào)用,因此,嚴(yán)格來說,子類無法重寫父類的便捷初始化器
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.如果
子類沒有自定義任何指定初始化器,它會(huì)自動(dòng)繼承父類所有的指定初始化器 - 2.如果
子類提供了父類所有指定初始化器的實(shí)現(xiàn)(要么通過方式1繼承，要么重寫)-
子類自動(dòng)繼承所有的父類便捷初始化器
-
- 3.就算子類添加了更多的便捷初始化器,這些規(guī)則仍然適用
- 4.
子類以便捷初始化器的形式重寫父類的指定初始化器,也可以作為滿足規(guī)則2的一部分
- 1.如果子類沒有自定義任何指定初始化器,它會(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
- 子類新增自定義便捷初始化器,如果子類沒有重寫父類初始化器,子類可以調(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ù)必須初始化值,才能保證父類繼承下來的初始化器能保證所有存儲(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)(要么通過方式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)(要么通過方式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)該初始化器(通過繼承或者重寫實(shí)現(xiàn)) - 如果
子類重寫了required初始化器,也必須加上required,不用加override
- 通過自動(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()方法,沒有重寫父類的指定初始化器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() // 此次沒有打印任何信息
- 在子類的初始化器中
賦值會(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ǔ)屬性的屬性觀察器, 則子類初始化器中對父類存儲(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è)初始化過程都失敗,并且之后的代碼都停止執(zhí)行 - 可以用一個(gè)非可失敗初始化器重寫一個(gè)可失敗初始化器,但反過來是不行的
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è)初始化過程都失敗,并且之后的代碼都停止執(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è)可失敗初始化器,但反過來是不行的
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)闆]有調(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í)例對象被釋放內(nèi)存時(shí),就會(huì)調(diào)用實(shí)例對象的deinit方法 -
結(jié)構(gòu)體和枚舉是不能使用deinit
class Person {
deinit {
print("Person deinit") // 實(shí)例對象被釋放會(huì)調(diào)用deinit
}
}
func test() {
var p1 = Person()
}
print("1") // 1
test() // Person deinit
print("2") // 2
-
deinit不接受任何參數(shù),不能寫小括號,不能自行調(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 語法
底層原理與內(nèi)存管理分析 專題：【iOS Swift5語法】
