Swift 进阶（九）协议、元类型

协议（Protocol）

基本概念

协议可以用来定义方法、属性、下标的声明，协议可以被结构体、类、枚举遵守

protocol Drawable {
    func draw()
    var x: Int { get set } // get和set只是声明
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}

多个协议之间用逗号隔开

protocol Test1 { }
protocol Test2 { }
protocol Test3 { }

class TestClass: Test1, Test2, Test3 { }

协议中定义方法时不能有默认参数值

默认情况下，协议中定义的内容必须全部都实现

协议中的属性

协议中定义属性必须用var关键字

实现协议时的属性权限要不小于协议中定义的属性权限

• 协议定义get、set，用var存储属性或get、set计算属性去实现
• 协议定义get，用任何属性都可以实现

protocol Drawable {
    func draw()
    var x: Int { get set }
    var y: Int { get }
    subscript(index: Int) -> Int { get set }
}

class Person1: Drawable {
    var x: Int = 0
    let y: Int = 0
    
    func draw() {
        print("Person1 draw")
    }
    
    subscript(index: Int) -> Int {
        set { }
        get { index }
    }
}

class Person2: Drawable {
    var x: Int {
        get { 0 }
        set { }
    }
    
    var y: Int { 0 }
    
    func draw() {
        print("Person2 draw")
    }
    
    subscript(index: Int) -> Int {
        set { }
        get { index }
    }
}

class Person3: Drawable {
    var x: Int {
        get { 0 }
        set { }
    }
    
    var y: Int {
        get { 0 }
        set { }
    }
    
    func draw() {
        print("Person3 draw")
    }
    
    subscript(index: Int) -> Int {
        set { }
        get { index }
    }
}

static、class

为了保证通用，协议中必须用static定义类型方法、类型属性、类型下标

protocol Drawable {
    static func draw()
}

class Person1: Drawable {
    static func draw() {
        print("Person1 draw")
    }
}

class Person2: Drawable {
    class func draw() {
        print("Person2 draw")
    }
}

mutating

只有将协议中的实例方法标记为mutating，才允许结构体、枚举的具体实现修改自身内存

类在实现方法时不用加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
    mutating func draw() {
        x = 10
    }
}

init

协议中还可以定义初始化器init，非final类实现时必须加上required

目的是为了让所有遵守这个协议的类都拥有初始化器，所以加上required强制子类必须实现，除非是加上final不需要子类的类

protocol Drawable {
    init(x: Int, y: Int)
}

class Point: Drawable {
    required init(x: Int, y: Int) {
        
    }
}

final class Size: Drawable {
    init(x: Int, y: Int) {
        
    }
}

如果从协议实现的初始化器，刚好是重写了父类的指定初始化器，那么这个初始化必须同时加上required、override

protocol Livable {
    init(age: Int)
}

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

class Student: Person, Livable {
    required override init(age: Int) {
        super.init(age: age)
    }
}

协议中定义的init?、init!，可以用init、init?、init!去实现

protocol Livable {
    init()
    init?(age: Int)
    init!(no: Int)
}

class Person1: Livable {
    required init() {
        
    }
    
    required init?(age: Int) {
        
    }
    
    required init!(no: Int) {
        
    }
}

class Person2: Livable {
    required init() {
        
    }
    
    required init!(age: Int) {
        
    }
    
    required init?(no: Int) {
        
    }
}

class Person3: Livable {
    required init() {
        
    }
    
    required init(age: Int) {
        
    }
    
    required init(no: Int) {
        
    }
}

协议中定义的init，可以用init、init!去实现

protocol Livable {
    init()
    init?(age: Int)
    init!(no: Int)
}

class Person4: Livable {
    required init!() {
        
    }
    
    required init?(age: Int) {
        
    }
    
    required init!(no: Int) {
        
    }
}

协议的继承

一个协议可以继承其他协议

protocol Runnable {
    func run()
}

protocol Livable: Runnable {
    func breath()
}

class Person: Livable {
    func breath() {
        
    }
    
    func run() {
        
    }
}

协议组合

协议组合可以包含一个类类型

protocol Runnable { }
protocol Livable { }
class Person { }

// 接收Person或者其子类的实例
func fn0(obj: Person) { }

// 接收遵守Livable协议的实例
func fn1(obj: Livable) { }

// 接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable & Runnable) { }

// 接收同时遵守Livable、Runnable协议，并且是Person或者其子类的实例
func fn3(obj: Person & Livable & Runnable) { }

typealias RealPerson = Person & Livable & Runnable
func fn4(obj: RealPerson) { }

CaseIterable

让枚举遵守CaseIterable协议，可以实现遍历枚举值

enum Season: CaseIterable {
    case spring, summer, autumn, winter
}

let seasons = Season.allCases
print(seasons.count)

for season in seasons {
    print(season)
} // spring, summer, autumn, winter

CustomStringConvertible

遵守CustomStringConvertible、CustomDebugStringConvertible协议，都可以自定义实例的打印字符串

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调用的是CustomStringConvertible协议的description

debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription

Any、AnyObject

Swift提供了两种特殊的类型Any、AnyObject

Any可以代表任意类型（枚举、结构体、类，也包括函数类型）

var stu: Any = 10
stu = "Jack"
stu = Size()

var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Size())
data.append("Jack")
data.append({ 10 })

AnyObject可以代表任意类类型

在协议后面写上: AnyObject，代表只有类能遵守这个协议

在协议后面写上: class，也代表只有类能遵守这个协议

is、as

is用来判断是否为某种类型

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

stu = "Jack"
print(stu is String) // true

stu = Student()
print(stu is Person) // true
print(stu is Student) // true
print(stu is Runnable) // true

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
(stu as? Student)?.study() // 没有调用study

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)

var d = 10 as Double
print(d) // 10.0

元类型

X.self

X.self是一个元类型的指针，metadata存放着类型相关信息

X.self属于X.Type类型

class Person { }

class Student: Person { }

var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
perType = Student.self

var anyType: AnyObject.Type = Person.self
anyType = Student.self

var per = Person()
perType = type(of: per)
print(Person.self == type(of: per)) // true

AnyClass的本质就是AnyObject.Type

var anyType2: AnyClass = Person.self
anyType2 = Student.self

元类型的应用

class Animal {
    required init() {
        
    }
}

class Cat: Animal {
    
}

class Dog: Animal {
    
}

class Pig: Animal {
    
}

func create(_ clses: [Animal.Type]) -> [Animal] {
    var arr = [Animal]()
    for cls in clses {
        arr.append(cls.init())
    }
    
    return arr
}

print(create([Cat.self, Dog.self, Pig.self]))

// a1、a2、a3、a4的写法等价
var a1 = Animal()
var t = Animal.self
var a2 = t.init()
var a3 = Animal.self.init()
var a4 = Animal.self()

Self

Self代表当前类型

class Person {
    var age = 1
    static var count = 2
    
    func run() {
        print(self.age)
        print(Self.count)
    }
}

Self一般用作返回值类型，限定返回值和方法调用者必须是同一类型（也可以作为参数类型）

protocol Runnable {
    func test() -> Self
}

class Person: Runnable {
    
    required init() {
        
    }
    
    func test() -> Self {
        type(of: self).init()
    }
}

class Student: Person {
    
}

var p = Person()
print(p.test()) // test_enum.Person

var stu = Student()
print(stu.test()) // test_enum.Student

元类型的本质

我们可以通过反汇编来查看元类型的实现是怎样的

var p = Person()
var pType = Person.self

我们发现最后存储到全局变量pType中的地址值就是一开始调用的地址

再通过打印，我们发现pType的值就是Person实例对象的前8个字节的地址值，也就是类信息

我们再来看下面的示例代码

var p = Person()
var pType = type(of: p)

通过分析我们可以看到type(of: p)本质不是函数调用，只是将Person实例对象的前8个字节存储到pType中，也证明了元类型的本质就是存储的类信息

我们还可以用以下方式来获取Swift的隐藏基类_TtCs12_SwiftObject

class Person {
    var age: Int = 0
}

class Student: Person {
    var no: Int = 0
}

print(class_getInstanceSize(Student.self)) // 32
print(class_getSuperclass(Student.self)!) // Person
print(class_getSuperclass(Student.self)!) // _TtCs12_SwiftObject
print(class_getSuperclass(NSObject.self)) // nil

我们可以查看Swift源码来分析该类型

发现SwiftObject里面也有一个isa指针