Swift 协议

协议可以用来声明方法、属性、下标，可以被枚举、结构体、类遵守，多个协议之间用逗号隔开。

关键字protocol

创建

protocol Drawable {
    func draw()
    var x: Int { 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，用任何属性都可以实现

-

static、class

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

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

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

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!，可以用init、init?、init!去实现。
  协议中定义的init，可以用init、init!去实现

 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) { }
}

协议的继承

类似于 类的继承

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

协议组合

可以包含1个类类型。(最多1个)

protocol Livable { }
protocol Runnable { }
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

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

CaseIterable

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

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协议，可以自定义实例的打印字符串

 class Person : CustomStringConvertible {
    var age: Int
    var name: String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
    // 实例的打印字符串
    var description: String {
        "age=\(age), name=\(name)"
    } 
}
var p = Person(age: 10, name: "Jack")
print(p) // age=10, name=Jack

Any、AnyObject

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

• Any
  可以代表任意类型 (枚举、结构体、类，也包括函数类型)
• AnyObject
  可以代表任意类类型(在协议后面写上: AnyObject代表只有类能遵守这个协议)

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

 // 创建1个能存放任意类型的数组 
 var data = Array<Any>() 
// 添加元素
 data.append(1) 
 data.append(3.14)
 data.append(Student()) 
 data.append("Jack") 
 data.append({ 10 })

is、as?、as!、as

is用来判断 是否为某种类型，as用来做 强制类型转换

var stu1: Any = 10
print(stu1 is Int) // true

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

X.self、X.Type、AnyClass

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

Self

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

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

var p = Person()
// Person
print(p.test())
var stu = Student()
// Student
print(stu.test())