• 定义： 协议定义了一个蓝图，规定了用来实现某一特定的任务或者功能的方法、属性，或其他需要的东西。
• 类、结构体、枚举都可以遵循协议，并为协议定义的这鞋要求提供具体实现。某个类型能满足某个协议的要求，就可以说该类型遵循这个协议。
• 除了遵循协议的类型必须实现的要求外，还可以对协议进行扩展，通过扩展来实现一部分要求或者实现一些附加功能，这样遵循协议的类型就能够使用这些功能。

协议语法

• 协议定义方式和类、结构体和枚举的定义方式类似：

protocol SomeProtocol {
  // 这里是协议的定义部分
}

• 自定义类型遵循某个协议时，要在类型名称后加上些协议名称，中间用冒号:分割。遵循多个协议是，各个协议之间用逗号,隔开：

struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 这里是结构体的定义部分
}

• 当拥有父类在遵循协议时，用该将父类放在协议名之前，用逗号,隔开：

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 这里是类的定义部分
}

属性协议

• 协议可以要求遵循协议的类型提供特定名称和类型的实例属性或类型属性。协议不指定属性是存储型属性还是计算型属性，它只指定属性的名称和类型。此外，协议还指定属性是可读的还是可读可写的。
• 如果协议要求属性是可读可写的，那么该属性不能是常量属性或只读的计算型属性。如果协议只要求属性是可读的，那么该属性不仅可以是可读的，如果代码需要的话，还可以是可写的。
• 协议总是用 var 关键字来声明变量属性，在类型声明后加上 { set get } 来表示属性是可读可写的，可读属性则用 { get } 来表示：

protocol SomeProtocol {
    var mustBeSettable: Int { get set }
    var doesNotNeedToBeSettable: Int { get }
}

当协议中定义类型属性时，总是使用static关键字作为前缀。当类类型遵循协议时，除了static，还可以用class关键字来生命类类型属性：

protocol AnotherProtocol {
    static var someTypeProperty: Int { get set }
}

如下所示，这是一个只含有一个实例属性要求的协议：

protocol FullNamed{
  var fullNamed: String{ get }
}

FullName协议除了要求遵循协议的类型提供fullname属性之外，并无其他要求。
下面是一个遵循FullNamed协议的一个结构体：

struct Person: fullNamed{
  var fullNamed: string
}
let john = Person(fullName: "John Appleseed")

Person结构体中每一个实例都有一个叫fullnamed的存储型属性。

class Starship: FullyNamed {
    var prefix: String?
    var name: String
    init(name: String, prefix: String? = nil) {
        self.name = name
        self.prefix = prefix
    }
    var fullName: String {
        return (prefix != nil ? prefix! + " " : "") + name
    }
}

Starship来吧fullname属性实现为只读的计算型属性。

方法协议

• 协议可以要求遵循协议的类型实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是，不支持为协议中的方法的参数提供默认值。
• 在协议中定义类方法的时候，总是使用static关键字作为前缀。当类类型遵循协议时，也可以使用class关键字作为前缀。

protocol SomeProtocol {
    static func someTypeMethod()
}

下面的协议之定义了一个实例方法：

protocol RandomNumberGenerator {
    func random() -> Double
}

RandomNumberGenerator 协议要求遵循协议的类型必须要实现一个名为random，返回值为Double类型的实例方法。RandomNumberGenerator协议并不关心具体的方法实现。

class LinearCongruentialGenerator: RandomNumberGenerator {
    var lastRandom = 42.0
    let m = 139968.0
    let a = 3877.0
    let c = 29573.0
    func random() -> Double {
        lastRandom = ((lastRandom * a + c) % m)
        return lastRandom / m
    }
}
let generator = LinearCongruentialGenerator()
print("Here's a random number: \(generator.random())")
// 打印 “Here's a random number: 0.37464991998171”
print("And another one: \(generator.random())")
// 打印 “And another one: 0.729023776863283”

Mutating协议要求

• 作用：在方法中改变方法所属的实例。
• 在值类型（即结构体和枚举）的实例方法中，将 mutating 关键字作为方法的前缀，写在 func 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。
• 如果你在协议中定义了一个实例方法，该方法会改变遵循该协议的类型的实例，那么在定义协议时需要在方法前加 mutating 关键字。这使得结构体和枚举能够遵循此协议并满足此方法要求。
• 实现协议中的 mutating 方法时，若是类类型，则不用写 mutating 关键字。而对于结构体和枚举，则必须写 mutating 关键字。

如下所示：

protocol Togglable {
    mutating func toggle()
}

定义了一个只有一个toggle的实例方法，这个方法允许修改实例属性的值。
当使用枚举或者结构体来实现Togglable协议时，需要实现一个前缀为mutating关键字的toggle方法。

下为一个OnOffSwitch的枚举。有开、关两种状态，用枚举成员On和Off表示。toggle方法前缀为mutating满足Togglable协议要求。

enum OnOffSwitch: Togglable {
    case Off, On
    mutating func toggle() {
        switch self {
        case Off:
            self = On
        case On:
            self = Off
        }
    }
}
var lightSwitch = OnOffSwitch.Off
lightSwitch.toggle()
// lightSwitch 现在的值为 .On

构造器协议

协议可以要求遵循协议的类型实现指定的构造器。

protocol SomeProtocol{
  init(somePara:Int)
}

必要构造器

在遵循协议的类中实现构造器，无论是作为指定构造器，还是作为便利构造器。无论哪种情况，你都必须为构造器实现标上 required 修饰符：

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
        // 这里是构造器的实现部分
    }
}

使用required修饰符可以确保所有子类也必须提供构造器实现，从而也能符合协议。

如果类已经被标记为 final，那么不需要在协议构造器的实现中使用 required 修饰符，因为 final 类不能有子类。关于 final 修饰符的更多内容，请参见防止重写。

如果一个子类重写了父类的指定构造器，并且该构造器满足了某个协议的要求，那么该构造器的实现需要同时标注 required 和 override 修饰符：

protocol SomeProtocol {
    init()
}
 
class SomeSuperClass {
    init() {
        // 这里是构造器的实现部分
    }
}
 
class SomeSubClass: SomeSuperClass, SomeProtocol {
    // 因为遵循协议，需要加上 required
    // 因为继承自父类，需要加上 override
    required override init() {
        // 这里是构造器的实现部分
    }
}

可失败构造器

• 协议还可以遵循协议的类型定义可失败构造器。
• 遵循协议的类型可以通过可失败构造器(init?)或非可失败构造器(init)来满足协议中定义的可失败构造器要求。协议中定义的非可失败构造器要求可以通过非可失败构造器（init）或隐式解包可失败构造器（init）来满足。

协议作为类型

• 尽管协议本身并未实现任何功能，但是协议可以被当做一个成熟的类型来使用。

协议可以像其他普通类型一样使用，使用场景如下：

• 作为函数、方法或构造器中的参数类型或者返回值类型
• 作为常量、变量或属性的类型
• 作为数组、字典或其他容器的元素类型

协议是一种类型，因此协议类型的名称应与其他类型（例如 Int，Double，String）的写法相同，使用大写字母开头的驼峰式写法，例如（FullyNamed 和 RandomNumberGenerator）。

class Dice {
    let sides: Int
    let generator: RandomNumberGenerator
    init(sides: Int, generator: RandomNumberGenerator) {
        self.sides = sides
        self.generator = generator
    }
    func roll() -> Int {
        return Int(generator.random() * Double(sides)) + 1
    }
}

上面定义了一个Dice类，代表桌球中拥有N个面的🎲。Dice创建的实例包含sides和generator两个属性，前者代表有几个面，后者为🎲提供一个随机数生成器，生成随机点数。

generator属性类型为RandomNumberGenerator，因此所有遵循RandomNumberGenerator协议的类型的实例都可以赋值给generator，除此之外没有其他要求。

Dice 类还有一个构造器，用来设置初始状态。构造器有一个名为 generator，类型为 RandomNumberGenerator 的形参。在调用构造方法创建 Dice 的实例时，可以传入任何遵循 RandomNumberGenerator 协议的实例给 generator。

Dice 类提供了一个名为 roll 的实例方法，用来模拟骰子的面值。它先调用 generator 的 random() 方法来生成一个 [0.0,1.0) 区间内的随机数，然后使用这个随机数生成正确的骰子面值。因为 generator 遵循了 RandomNumberGenerator 协议，可以确保它有个 random() 方法可供调用。

var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
    print("Random dice roll is \(d6.roll())")
}
// Random dice roll is 3
// Random dice roll is 5
// Random dice roll is 4
// Random dice roll is 5
// Random dice roll is 4

代理模式

• 代理是一种设计模式，它允许类或结构体将一些需要它们负责的功能委托给其他类型的实例。
• 定义：定义协议来封装那些需要被委托的功能，这样就能确保遵循协议的类型能提供这些功能。
• 代理模式可以用来相应特定的动作，或者接受外部数据源提供的数据，为不用关心外部数据源的类型。

通过扩展添加协议一致性

在无法修改源代码的情况下，依然可以通过扩展令已有类型遵循并符合协议。扩展可以为已有类型添加属性、方法、下标以及构造器，可以符合协议中的要求。

通过扩展使已有类型遵循并符合协议时，该类型的所有势力也会随之获得协议中定义的各项功能。

举个🌰，下面有个TextRepresentable协议，任何想要通过文本表达一些内容的类型都可以实现该协议。

protocol TextRepresentable {
   var textualDescription: String { get }
}

可以通过扩展，可以使Dice类遵循协议实现协议方法：

extension Dice: TextRepresentable {
   var textualDescription: String {
       return "A \(sides)-sided dice"
   }
}

通过扩展遵循并符合协议，和在原始定义中遵循并符合协议的效果完全相同。协议名称写在类型名之后，以冒号隔开，然后在扩展的大括号内实现协议要求的内容。

通过扩展遵循协议

当一个类已经符合了某个协议中的所有要求，却没有生命遵循该协议时，可以通过空扩展体的扩展来遵循该协议：

struct Hamster {
    var name: String
       var textualDescription: String {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentable {}

let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
print(somethingTextRepresentable.textualDescription)
// 打印 “A hamster named Simon

注意：即使满足了协议的所有要求，类型也不会自动遵循协议，必须显式地遵循协议。

协议类型的集合

协议类型可以在数组或者字典这样的集合中使用。

下面创建了一个元素类型为TextRepresentable的数组：

let things: [TextRepresentable] = [game, d12, simonTheHamster]

通过遍历things数组，打印每个元素的文本表示：

for thing in things {
    print(thing.textualDescription)
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice

thing 是 TextRepresentable 类型而不是 Dice，DiceGame，Hamster 等类型，即使实例在幕后确实是这些类型中的一种。由于 thing 是 TextRepresentable 类型，任何 TextRepresentable 的实例都有一个 textualDescription 属性，所以在每次循环中可以安全地访问 thing.textualDescription。

协议的继承

协议能够继承一个或者多个其他协议，可以在继承的协议的基础上增加新的要求。协议的继承语法与类的继承相似，多个被继承的协议间用逗号隔开：

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 这里是协议的定义部分
}

类类型专属协议

通过添加 class 关键字来限制协议只能被类类型遵循，而结构体或枚举不能遵循该协议。class 关键字必须第一个出现在协议的继承列表中，在其他继承的协议之前：

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
    // 这里是类类型专属协议的定义部分
}

协议 SomeClassOnlyProtocol 只能被类类型遵循。如果尝试让结构体或枚举类型遵循该协议，则会导致编译错误。

协议合成

有时需要遵循多个协议，可以将多个协议采用SomeProtocol & AnotherProtocol 这样的格式进行组合，成为协议合成。
可以罗列任意多个你想要遵循的协议，以与符号(&)分隔。
举个🌰：

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(to: birthdayPerson)
// 打印 “Happy birthday Malcolm - you're 21!

这段代码中声明了Named和Aged协议，一个遵循了这两个协议的结构体Person,Person并实现了这两个协议。

wishHappyBirthday(to:) 函数的参数 celebrator 的类型为 Named & Aged。这意味着它不关心参数的具体类型，只要参数符合这两个协议即可。

协议合成并不会生成新的、永久的协议类型，而是将多个协议中的要求合成到一个只在局部作用域有

检查协议一致性

使用类型转换中描述的 is 和 as 操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型。检查和转换到某个协议类型在语法上和类型的检查和转换完全相同：

• 使用类型转换中描述的 is 和 as 操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型。检查和转换到某个协议类型在语法上和类型的检查和转换完全相同：
• is 用来检查实例是否符合某个协议，若符合则返回 true，否则返回 false。
• as? 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 nil。

举个🌰吧：定义一个HasArea的协议，定义了一个只读属性area

protocol HasArea{
  var area: Double{get}
}

定义一个Circle和一个Country类，都遵循了HasArea协议：

class Circle: HasArea {
    let pi = 3.1415927
    var radius: Double
    var area: Double { return pi * radius * radius }
    init(radius: Double) { self.radius = radius }
}
class Country: HasArea {
    var area: Double
    init(area: Double) { self.area = area }
}

最后定义一个Animal类，但是没有遵循HasArea协议：

class Animal {
    var legs: Int
    init(legs: Int) { self.legs = legs
    }
}

Circle，Country，Animal 并没有一个共同的基类，尽管如此，它们都是类，它们的实例都可以作为 AnyObject 类型的值，存储在同一个数组中：

let objects: [AnyObject] = [
    Circle(radius: 2.0),
    Country(area: 243_610),
    Animal(legs: 4)
]

最后当要对objects数组进行迭代，并对每一个元素进行检查，看它是否符合HasArea协议：

for object in objects {
    if let objectWithArea = object as? HasArea {
        print("Area is \(objectWithArea.area)")
    } else {
        print("Something that doesn't have an area")
    }
}
// Area is 12.5663708
// Area is 243610.0
// Something that doesn't have an area

当迭代出的元素符合HasArea协议时，将as?操作符返回的可选值通过可选绑定，绑定到objectWithArea常量上。

objects数组中的元素类型并不会因为强转而丢失类型信息，仍然是Circle,Country,Animal类型。当被赋值给objectWithArea时，只被视为HasArea类型，因此只有area属性能够被访问。

可选的协议要求

• 协议可以定义可选要求，遵循协议的类型可以选择是否实现这些要求。在协议中使用optional关键字作为前缀来定义可选要求。可选要求用在需要和OC打交道的代码中。协议和可选要求都必须带上@objc属性。标记@objc特性的协议只能被继承自OC类的类或者@objc类遵循，其他类以及结构体和枚举不能遵循这种协议。

• 使用可选属性或者方法时，它们的类型会自动编程可选的。比如一个(Int)->String的方法会变成((Int)->String)?。注意：是整个函数类型是可选的，而不是函数的返回值。

下面的例子定义了一个名为 Counter 的用于整数计数的类，它使用外部的数据源来提供每次的增量。数据源由 CounterDataSource 协议定义，包含两个可选要求：

@objc protocol CounterDataSource {
    optional func incrementForCount(count: Int) -> Int
    optional var fixedIncrement: Int { get }
}

严格来讲，CounterDataSource 协议中的方法和属性都是可选的，因此遵循协议的类可以不实现这些要求，尽管技术上允许这样做，不过最好不要这做。

Counter 类含有 CounterDataSource? 类型的可选属性 dataSource，如下所示：

class Counter {
    var count = 0
    var dataSource: CounterDataSource?
    func increment() {
        if let amount = dataSource?.incrementForCount?(count) {
            count += amount
        } else if let amount = dataSource?.fixedIncrement {
            count += amount
        }
    }
}

Counter 类使用变量属性 count 来存储当前值。该类还定义了一个 increment 方法，每次调用该方法的时候，将会增加 count 的值。

increment() 方法首先试图使用 increment(forCount:) 方法来得到每次的增量。increment() 方法使用可选链式调用来尝试调用 increment(forCount:)，并将当前的 count 值作为参数传入。

这里使用了两层可选链式调用。首先，由于 dataSource 可能为 nil，因此在 dataSource 后边加上了 ?，以此表明只在 dataSource 非空时才去调用 increment(forCount:) 方法。其次，即使 dataSource 存在，也无法保证其是否实现了 increment(forCount:) 方法，因为这个方法是可选的。因此，increment(forCount:) 方法同样使用可选链式调用进行调用，只有在该方法被实现的情况下才能调用它，所以在 increment(forCount:) 方法后边也加上了 ?。

协议扩展

协议可以通过扩展来为遵循协议的类型提供属性。方法以及下标的实现。通过这种方式，基于协议本身来实现这些功能，而无需在每个遵循协议的类型中重复同样的实现，也无需使用全局函数。

例如：通过扩展RandomNumberGenerator协议来提供randomBool()方法。该方法使用协议中定义的random方法来返回一个随机bool值：

extension RandomNumberGenerator {
    func randomBool() -> Bool {
        return random() > 0.5
    }
}

通过协议扩展，所有遵循协议的类型，都能自动获取这个扩展所增加的方法实现，无需任何额外修改：

let generator = LinearCongruentialGenerator()
print("Here's a random number: \(generator.random())")
// 打印 “Here's a random number: 0.37464991998171”
print("And here's a random Boolean:“(generator.randomBool())")
// 打印 “And here's a random Boolean: true

提供默认实现

可以通过协议扩展来为协议要求的属性。方法以及下标提供默认的实现。如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中的默认实现被使用。

通过协议扩展为协议要求提供的默认实现和可选的协议要求不同。虽然在这两种情况下，遵循协议的类型都无需自己实现这些要求，但是通过扩展提供的默认实现可以直接调用，而无需使用可选链式调用。

为协议扩展添加限制条件

在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。

这些县纸条简卸载协议名之后，使用where子句来描述。

extension CollectionType where Generator.Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" +itemsAsText.joinWithSeparator(", ") + "]"
    }
}

textualDescription 属性返回整个集合的文本描述，它将集合中的每个元素的文本描述以逗号分隔的方式连接起来，包在一对方括号中。

textualDescription 属性返回整个集合的文本描述，它将集合中的每个元素的文本描述以逗号分隔的方式连接起来，包在一对方括号中。

let murrayTheHamster = Hamster(name: "Murray")
let morganTheHamster = Hamster(name: "Morgan")
let mauriceTheHamster = Hamster(name: "Maurice")
let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]

因为 Array 符合 CollectionType 协议，而数组中的元素又符合 TextRepresentable 协议，所以数组
可以使用 textualDescription 属性得到数组内容的文本表示：

可以使用 textualDescription 属性得到数组内容的文本表示：

注意
如果多个协议扩展都为同一个协议要求提供了默认实现，而遵循协议的类型又同时满足这些协议扩展的限制条件，那么将会使用限制条件最多的那个协议扩展提供的默认实现。