一. 可選鏈（Optional Chaining）
- 如果可選項為nil，調(diào)用方法、下標(biāo)、屬性失敗，結(jié)果為nil
- 如果可選項不為nil，調(diào)用方法、下標(biāo)、屬性成功，結(jié)果會被包裝成可選項
- 如果結(jié)果本來就是可選項，不會進(jìn)行再次包裝
class Car { var price = 0 }
class Dog { var weight = 0 }
class Person {
var name: String = ""
var dog: Dog = Dog()
var car: Car? = Car()
func age() -> Int? { 18 }
func eat() { print("Person eat") }
subscript(index: Int) -> Int { index }
}
var person: Person? = Person()
//這樣強制解包有風(fēng)險，如果person是nil，使用nil調(diào)用方法會報錯
var age1 = person!.age() // Int
//age是Int?類型的，不會進(jìn)行再次包裝
var age2 = person?.age() // Int?
var name = person?.name // String?
var index = person?[6] // Int?
Value of optional type 'Person?' must be unwrapped to refer to member 'eat' of wrapped base type 'Person'
如果
person是可選類型image-20210415130621894兩種方式,一種是在
person后面加感嘆號!,進(jìn)行強制解包var result = person!.eat()使用感嘆號
!強制解包這種做法不安全,一旦person對象為nil,程序就會崩潰.另一種是加問號
?:image-20210415130743910加
?的意思時會先判斷person對象是否為nil,如果為nil,就不會再調(diào)用eat,直接返回nil;
func getName() -> String { "jack" }
// 如果person是nil，不會調(diào)用getName()
person?.name = getName()
- 如何判斷可選項調(diào)用方法是否成功？
var person : Person?
if let _ = person?.eat() { // ()?
print("eat調(diào)用成功")
} else {
print("eat調(diào)用失敗")
}
Swift里面，如果方法調(diào)用沒有返回值就相當(dāng)于返回一個空元祖()，所以可以根據(jù)是否返回空元祖來判斷方法是否調(diào)用成功
image-20210415120124685
- 多個?鏈接在一起就稱為可選鏈，
如果鏈中任何一個節(jié)點是nil，那么整個鏈就會調(diào)用失敗：
var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?
字典通過key獲取的值都是可選類型，可選類型使用的時候要加?
//字典
var scores = ["Jack": [86, 82, 84], "Rose": [79, 94, 81]]
//通過字典的key獲取值有可能獲取失敗，所以結(jié)果是可選類型的數(shù)組
scores["Jack"]?[0] = 100
//可選類型的數(shù)組通過下標(biāo)訪問成員需要加？
scores["Rose"]?[2] += 10
scores["Kate"]?[0] = 88
可選項不會進(jìn)?再次包裝，除?你給他指定類型：
var num1: Int? = 5
var num2: Int?? = 10
print(num2) //Optional(Optional(10))
var dict: [String : (Int, Int) -> Int] = [
"sum" : (+),
"difference" : (-)
]
//返回的函數(shù)是個可選類型，函數(shù)調(diào)用的時候也要加?
var result = dict["sum"]?(10, 20) // Optional(30)
二. 協(xié)議（Protocol）
1. 協(xié)議簡介
協(xié)議可以用來定義方法、屬性、下標(biāo)的聲明,協(xié)議可以被枚舉、結(jié)構(gòu)體、類遵守（多個協(xié)議之間用逗號隔開）
protocol Drawable {
func draw() //方法聲明
var x: Int { get set } //屬性聲明
var y: Int { get }
subscript(index: Int) -> Int { get set } //下標(biāo)聲明
}
- 協(xié)議可以被枚舉、結(jié)構(gòu)體、類遵守（多個協(xié)議之間用逗號隔開）
protocol Test1 {}
protocol Test2 {}
protocol Test3 {}
class TestClass : Test1, Test2, Test3 {}
- 協(xié)議中定義方法時不能有默認(rèn)參數(shù)值
- 默認(rèn)情況下，協(xié)議中定義的內(nèi)容必須全部都實現(xiàn)
- 也有辦法辦到只實現(xiàn)部分內(nèi)容
2. 協(xié)議中的屬性
協(xié)議中定義屬性時必須用var關(guān)鍵字(因為屬性可能通過計算屬性來實現(xiàn)，將來返回什么不確定)
-
實現(xiàn)協(xié)議時的屬性權(quán)限要不小于協(xié)議中定義的屬性權(quán)限
協(xié)議中屬性定義成get set，可以用var存儲屬性或者get set計算屬性去實現(xiàn)
協(xié)議中定義成get，用任何屬性(let y、只有g(shù)et的計算屬性、有g(shù)et set的計算屬性)都可以實現(xiàn)
如下類遵守Drawable協(xié)議：
protocol Drawable {
func draw() //方法聲明
var x: Int { get set } //屬性聲明，必須用var
var y: Int { get }
subscript(index: Int) -> Int { get set } //下標(biāo)
}
//1：
class Person : Drawable {
var x: Int = 0
let y: Int = 0
func draw() {
print("Person draw")
}
subscript(index: Int) -> Int {
set {}
get { index }
}
}
//2：
class Person : Drawable {
var x: Int {
get { 0 }
set {}
}
var y: Int { 0 }
func draw() { print("Person draw") }
subscript(index: Int) -> Int {
set {}
get { index }
}
}
- 定義屬性時必須用var關(guān)鍵字
image-20210415131308927
- 實現(xiàn)協(xié)議時的屬性權(quán)限要不小于協(xié)議中定義的屬性權(quán)限
image-20210415131523522
3. 協(xié)議關(guān)鍵字
- static、class
為了保證枚舉、結(jié)構(gòu)體、類通用，協(xié)議中必須用static定義類型方法、類型屬性、類型下標(biāo)。
但是，具體使用的時候如果是類，還是可以用class的。
我們知道
class和static都可以用來定義類型計算屬性,類型方法,類型下標(biāo).但是如果要在協(xié)議中定義類型方法,類型屬性只能用static.因為協(xié)議可以被類,結(jié)構(gòu)體,枚舉遵守.而class只能在類中使用.
protocol Drawable {
static func draw()
}
class Person1 : Drawable {
class func draw() {
print("Person1 draw")
}
}
class Person2 : Drawable {
static func draw() {
print("Person2 draw")
}
}
- mutating
只有將協(xié)議中的實例方法標(biāo)記為mutating，才允許枚舉、結(jié)構(gòu)體的具體實現(xiàn)修改自身內(nèi)存，在實現(xiàn)的時候，枚舉、結(jié)構(gòu)體需要加mutating，類不用加mutating。
protocol Drawable {
mutating func draw()
}
class Size : Drawable {
var width: Int = 0
func draw() {
width = 10
}
}
struct Point : Drawable {
var x: Int = 0
//只有在協(xié)議中先加上mutating，在枚舉、結(jié)構(gòu)體中實現(xiàn)的時候才可以在這里加mutating
mutating func draw() {
x = 10
}
}
image-20210415132227877
- init
協(xié)議中還可以定義初始化器init，非final類實現(xiàn)時必須加上required
protocol Drawable {
init(x: Int, y: Int)
}
class Point : Drawable {
required init(x: Int, y: Int) {}//必須加上required
}
final class Size : Drawable {
init(x: Int, y: Int) {}
}
如果從協(xié)議實現(xiàn)的初始化器，剛好是重寫了父類的指定初始化器，那么這個初始化必須同時加required、override
protocol Livable {
init(age: Int)
}
class Person {
init(age: Int) {}
}
//required來自協(xié)議，override來自父類
class Student : Person, Livable {
required override init(age: Int) {//重寫了父類的指定初始化器，那么這個初始化必須同時加required、override
super.init(age: age)
}
}
- init、init?、init!
init：非可失敗初始化器
init?：可失敗初始化器
init!：可失敗初始化器(隱式解包)
協(xié)議中定義的init?、init!，可以用init、init?、init!去實現(xiàn)
協(xié)議中定義的init，可以用init、init!去實現(xiàn)
protocol Livable {
init()
init?(age: Int)
init!(no: Int)
}
class Person : Livable {
required init() {}
// required init!() {}
required init?(age: Int) {}
// required init!(age: Int) {}
// required init(age: Int) {}
required init!(no: Int) {}
// required init?(no: Int) {}
// required init(no: Int) {}
}
- 協(xié)議繼承
協(xié)議之間可以彼此繼承,一個協(xié)議可以繼承另一個協(xié)議.
protocol Runnable {
func run()
}
protocol Livable : Runnable {
func breath()
}
class Person : Livable {
func breath() {}
func run() {}
}
- 協(xié)議組合
協(xié)議組合，可以將協(xié)議和類組合起來(最多只能包含一個類類型)
protocol Livable {}
protocol Runnable {}
class Person {}
// 接收Person或者其子類的實例
func fn0(obj: Person) {}
// 接收遵守Livable協(xié)議的實例
func fn1(obj: Livable) {}
// 接收同時遵守Livable、Runnable協(xié)議的實例
func fn2(obj: Livable & Runnable) {}
// 接收同時遵守Livable、Runnable協(xié)議、并且是Person或者其子類的實例
func fn3(obj: Person & Livable & Runnable) {}
typealias RealPerson = Person & Livable & Runnable
// 接收同時遵守Livable、Runnable協(xié)議、并且是Person或者其子類的實例
func fn4(obj: RealPerson) {}
注意: 只能用 & 組合協(xié)議,不能使用 | 組合協(xié)議,因為使用 | 組合還要單獨區(qū)分具體是哪個類,這樣做毫無意義.
一些常用協(xié)議
CaseIterable
讓枚舉遵守CaseIterable協(xié)議，可以實現(xiàn)遍歷枚舉值，CaseIterable協(xié)議源碼如下：
public protocol CaseIterable {
/// A type that can represent a collection of all values of this type.
associatedtype AllCases : Collection where Self == Self.AllCases.Element
/// A collection of all values of this type.
static var allCases: Self.AllCases { get }
}
enum Season : CaseIterable {
case spring, summer, autumn, winter
}
let seasons = Season.allCases
print(seasons.count) // 4
for season in seasons {
print(season) // spring summer autumn winter
}
- CustomStringConvertible
遵守CustomStringConvertible、CustomDebugStringConvertible協(xié)議，都可以自定義實例的打印字符串，協(xié)議源碼如下：
public protocol CustomStringConvertible {
var description: String { get }
}
public protocol CustomDebugStringConvertible {
var debugDescription: String { get }
}
class Person : CustomStringConvertible, CustomDebugStringConvertible {
var age = 0
var description: String { "person_\(age)" }
var debugDescription: String { "debug_person_\(age)" }
}
var person = Person()
print(person) // person_0
debugPrint(person) // debug_person_0
- print調(diào)用的是CustomStringConvertible協(xié)議的description
- debugPrint、po調(diào)用的是CustomDebugStringConvertible協(xié)議的debugDescription
類型相關(guān)關(guān)鍵字
- Any、AnyObject
Swift提供了兩種特殊的類型：Any、AnyObject
- Any：可以代表任意類型（枚舉、結(jié)構(gòu)體、類，也包括函數(shù)類型）
- AnyObject：可以代表任意類類型（在協(xié)議后面寫上:
AnyObject代表只有類能遵守這個協(xié)議，在協(xié)議后面寫上:class也代表只有類能遵守這個協(xié)議）
var stu: Any = 10
stu = "Jack"
stu = Student()
// 創(chuàng)建1個能存放任意類型的數(shù)組
// var data = Array<Any>()
var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Student())
data.append("Jack")
data.append({ 10 })
- is、as?、as!、as
- is用來判斷是否為某種類型，
- as用來做強制類型轉(zhuǎn)換
as?、as!、as的區(qū)別：
- as?和as!都代表可選類型
- as?表示可能強轉(zhuǎn)成功也可能強轉(zhuǎn)失敗
- as!表示強轉(zhuǎn)之后進(jìn)行隱式解包
- 百分百可以強轉(zhuǎn)成功就使用as
protocol Runnable { func run() }
class Person {}
class Student : Person, Runnable {
func run() {
print("Student run")
}
func study() {
print("Student study")
}
}
var stu: Any = 10
print(stu is Int) // true 是否是Int
stu = "Jack"
print(stu is String) // true 是否是String
stu = Student()
print(stu is Person) // true 是否是Person及其子類
print(stu is Student) // true 是否是Student及其子類
print(stu is Runnable) // true 是否是遵守Runnable協(xié)議的類
var stu: Any = 10
(stu as? Student)?.study() // 沒有調(diào)用study
//第一個?代表強制轉(zhuǎn)換可能成功可能失敗，第二個?代表可選類型調(diào)用方法必須加?
stu = Student()
(stu as? Student)?.study() // Student study
(stu as! Student).study() // Student study
(stu as? Runnable)?.run() // Student run
var data = [Any]()
data.append(Int("123") as Any) //百分百可以轉(zhuǎn)換成功就使用as
var d = 10 as Double //百分百可以轉(zhuǎn)換成功就使用as
print(d) // 10.0
注意可選鏈：
(stu as? Student)?.study() 第一個?代表強制轉(zhuǎn)換可能成功可能失敗，第二個?代表可選類型調(diào)用方法必須加?
(stu as? Student)!.study()
(stu as! Student).study()
上面兩種寫法完全等價，都代表隱式解包，但是上面第二種兩種寫法有風(fēng)險：一旦強制解包失敗會報錯
X.self. , X.Type , AnyClass(X表示的是類)
- X.self是一個元類型(metadata)的指針，metadata存放著類型相關(guān)信息(就是以前我們說的，對象堆空間前8字節(jié)存放的類型相關(guān)的那個指針)
- X.self屬于X.Type類型
- X.self有點類似于OC的X.class
- AnyObject代表任意類類型
- AnyClass就是AnyObject.Type，代表任意類的元類型
class Person {}
class Student : Person {
static var age = 0
}
var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
perType = Student.self //可以賦值
print(Person.self) //Person
print(Student.self) //Student
print(perType) //Person
print(stuType) //Student
var anyType: AnyObject.Type = Person.self
anyType = Student.self //可以賦值
print(anyType) //Person
print(anyType) //Person
public typealias AnyClass = AnyObject.Type //任意類的元類型
var anyType2: AnyClass = Person.self //可以賦值
anyType2 = Student.self //也可以賦值
var per1 = Person()
var per1Type = type(of: per1) //返回的就是Person.self
print(Person.self) //Person
print(type(of: per1)) //Person
print(type(of: per1) == Person.self) // true
如下所示代碼:
class Person{
}
var p = Person()
它的內(nèi)存分布如下:
p存儲的是Person實例對象的前8個字節(jié)的地址.這8個字節(jié)就是Person元類型地址.
X.self:是一個元類型(metadata)的地址,metadata中存放的是類型相關(guān)的信息.
也就是說X.self返回的是Person實例對象的前8個字節(jié)中存放的內(nèi)存地址,我們將通過匯編證明這一點.
匯編分析代碼:
class Person{
}
var p = Person()
var personType = Person.self
匯編分析:
image-2021041513392457012 行加斷點，再運行一遍
image-20210415134113816image-20210415134523193
personType中存放的內(nèi)容和Person對象的前8個字節(jié)的內(nèi)容相同
補充1：下面兩行完全一樣
class Person {
static var age = 0
}
Person.age = 10 //通過類型訪問age
Person.self.age = 10 //通過元類型訪問age
補充2：type(of: per1) == Person.self
//接收一個實例，告訴你這個實例是什么類型，返回的是X.Type類型
//Swift把它定性為函數(shù)，但它本質(zhì)不是函數(shù)調(diào)用，是直接取出per1對象的前8個字節(jié)賦值給左邊
var per1Type = type(of: per1) //返回的就是Person.self
type(of:)表面上看起來很像一個函數(shù),但是我們窺探它的匯編發(fā)現(xiàn)它的本質(zhì)就是直接取出實例對象的前8個字節(jié),并沒有函數(shù)調(diào)用image-20210415140537785
元類型的應(yīng)用
- 根據(jù)元類型創(chuàng)建實例
X.self有點類似于OC的X.class
class Animal { required init() {} } //確保子類都有init()
class Cat : Animal {}
class Dog : Animal {}
class Pig : Animal {}
//傳入元類型，創(chuàng)建出實例放到數(shù)組中返回
func create(_ clses: [Animal.Type]) -> [Animal] {
var arr = [Animal]()
for cls in clses {
arr.append(cls.init()) //元類型，調(diào)用init()
}
return arr
}
print(create([Cat.self, Dog.self, Pig.self]))
上面代碼“arr.append(cls.init())”，通過元類型調(diào)用init()，和我們通常寫的Animal()是一樣的，如下：
//通過窺探匯編可知，下面幾行完全一樣的
var a1 = Animal()
var a2 = Animal.self()
var a3 = Animal.init()
var a4 = Animal.self.init()
//甚至：
var a5 = type(of:a2).init() //type(of:a2)就是拿到Animal.self
他們本質(zhì)都是調(diào)用init()
Animal是類型，Animal.self是元類型，只不過很多時候Animal.self和Animal可以相互取代(如果要求傳入的就是元類型就不能取代)
- Swift中使用Runtime的一些函數(shù)
Swift雖然沒有Runtime，但是一些純Swift的類也可以使用Runtime的一些函數(shù)，因為Swift實現(xiàn)了這些函數(shù)
import Foundation
class Person {
var age: Int = 0
}
class Student : Person {
var no: Int = 0
}
//至少占用多少字節(jié)
print(class_getInstanceSize(Student.self)) // 32
//獲取父類
print(class_getSuperclass(Student.self)!) // Person
//獲取父類
print(class_getSuperclass(Person.self)!) // Swift._SwiftObject
從結(jié)果可以看得出來，Swift還有個隱藏的基類：Swift._SwiftObject
可以參考Swift源碼：https://github.com/apple/swift/blob/master/stdlib/public/runtime/SwiftObject.h
- Self
self代表方法調(diào)用者
Self代表當(dāng)前類型
class Person {
var age = 1
static var count = 2
func run() {
print(self.age) // 1
print(Self.count) // 2
}
}
Self一般用作返回值類型，限定返回值跟方法調(diào)用者必須是同一類型(也可以作為參數(shù)類型)
protocol Runnable {
func test() -> Self //限定返回值跟方法調(diào)用者必須是同一類型
}
class Person : Runnable {
required init() {} //必須是required
func test() -> Self {
type(of: self).init() //使用元類型調(diào)用init()
}
}
class Student : Person {}
var p = Person()
// Person
print(p.test())
var stu = Student()
// Student
print(stu.test())
特別備注
本系列文章總結(jié)自MJ老師在騰訊課堂Swift編程從入門到精通-MJ大神精選，相關(guān)圖片素材均取自課程中的課件。如有侵權(quán)，請聯(lián)系我刪除，謝謝！
