类、结构体或枚举都可以遵循协议，并为协议定义的这些要求提供具体实现。
除了遵循协议的类型必须实现的要求外，还可以对协议进行扩展，通过扩展来实现一部分要求或者实现一些附加功能，这样遵循协议的类型就能够使用这些功能。
protocol SomeProtocol {
// 这里是协议的定义部分
}
拥有父类的类在遵循协议时，应该将父类名放在协议名之前，以逗号分隔。
属性
协议不指定属性是存储型属性还是计算型属性，协议指定的是属性的名称和类型，以及属性是只读还是读写。
要求可读写，实现可以是读写。如果只要求了可读，可以实现为可读，也可实现为可读写。
protocol SomeProtocol {
var mustBeSettable: Int { get set } // 读写
var doseNotNeedToBeSettable: Int { get } // 只读 或者 读写
}
协议中的类型属性：
在协议中定义类型属性时，总是使用 static 关键字作为前缀。当类类型遵循协议时，除了 static 关键字，还可以使用 class 关键字来声明类型属性。
protocol AnotherProtocol {
static var someTypeProperty: Int { get set }
}
方法
类类型的方法常用static修饰，需要类遵守的用class。
protocol SomeProtocol {
static func someTypeMethod()
}
protocol RandomNumberGenerator {
func random() -> Double
}
可变方法
如果你在协议中定义了一个实例方法，该方法会改变遵循该协议的类型的实例，那么在定义协议时需要在方法前加 mutating 关键字。这使得结构体和枚举能够遵循此协议并满足此方法要求。
实现协议中的 mutating 方法时，若是类类型，则不用写 mutating 关键字。而对于结构体和枚举，则必须写 mutating 关键字。
protocol Togglable {
mutating func toggle()
}
构造器要求
协议可以要求遵循协议的类型实现指定的构造器。
类类型的话，实现构造器，需要加上required，以保证子类继承的时候，也能够遵守协议。如果类被标记为final，则不需要使用required，因为不会再有子类了。
protocol SomeProtocol {
init(someParameter: Int)
}
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// 这里是构造器的实现部分
}
}
如果一个子类重写了父类的指定构造器，并且该构造器满足了某个协议的要求，那么该构造器的实现需要同时标注 required 和 override 修饰符。
继承自父类的构造器，满足某个协议，则required 和 override同时使用。
可失败构造器要求
协议还可以为遵循协议的类型定义可失败构造器要求。
遵循协议的类型可以通过可失败构造器（init?）或非可失败构造器（init）来满足协议中定义的可失败构造器要求。协议中定义的非可失败构造器要求可以通过非可失败构造器（init）或隐式解包可失败构造器（init!）来满足。
协议作为类型
尽管协议本身并未实现任何功能，但是协议可以被当做一个成熟的类型来使用。
协议可以和其他类型一样使用：
- 作为函数方法构造器的参数类型或者返回值类型
- 作为常量、变量或者属性的类型
- 作为数组、字典等其他容器的元素类型
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
}
}
任何遵循了RandomNumberGenerator的实例，都可以赋值给generator，除此之外，并无其他要求。
委托
委托是一种设计模式，它允许类或结构体将一些需要它们负责的功能委托给其他类型的实例。
委托模式的实现很简单：定义协议来封装那些需要被委托的功能，这样就能确保遵循协议的类型能提供这些功能。
委托模式可以用来响应特定的动作，或者接收外部数据源提供的数据，而无需关心外部数据源的类型。
在扩展里添加协议遵循
通过扩展令已有类型遵循并符合协议时，该类型的所有实例也会随之获得协议中定义的各项功能。
有条件地遵循协议
泛型类型可能只在某些情况下满足一个协议的要求，比如当泛型的类型形式参数遵循对应协议时。可以通过在扩展类型时列出限制，让泛型类型有条件的遵守某协议。在你采纳协议的名字后面写泛型where分句。
在扩展里声明采纳协议
当一个类型已经符合了协议中的所有要求时，却还没有声明采纳该协议，可以通过空扩展提采纳该协议。
struct Hamster {
var name: String
var textualDescription: String {
return "A hamster name \(name)"
}
}
extension Hamster: TextRepresentable {}
即使满足了协议的所有要求，类型也不会自动遵循协议，必须显式地遵循协议。
协议类型的集合
协议类型可以在数组或者字典这样的集合中使用。
let things: [TextRepresentable] = [game, d12, simonTheHamster]
协议的继承
协议能够继承一个或多个其他协议，可以在继承的协议的基础上增加新的要求。
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 这里是协议的定义部分
}
遵循继承的协议，需要满足继承的所有协议。
类专属的协议
通过添加 AnyObject 关键字到协议的继承列表，就可以限制协议只能被类类型采纳（以及非结构体或者非枚举的类型）。
protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
// 这里是类专属协议的定义部分
}
添加AnyObject关键字。
当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时，应该采用类类型专属协议。
协议合成
使用协议组合来复合多个协议到一个要求里。
协议组合使用 SomeProtocol & AnotherProtocol 的形式。你可以列举任意数量的协议，用和符号（&）分开。除了协议列表，协议组合也能包含类类型，这允许你标明一个需要的父类。
例如：组合协议作为函数参数的类型，函数参数可以传递任何遵循这2个协议的类型实例。
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)!")
}
也可以是类和协议的组合。
检查类型的一致性
可以使用类型转换中的is 和 as来判断协议的一致性，即是否符合某协议，并且可以转换到指定协议类型。
- is 用来检查实例是否符合某个协议，若符合则返回 true，否则返回 false。
- as? 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 nil。
- as! 将实例强制向下转换到某个协议类型，如果强转失败，会引发运行时错误。
let objects: [AnyObject] = [Circle(radius: 2.0), Country(area: 22323), Animal(legs: 4)]
for object in objects {
if let objectWithArea = object as? HasArea {
print("\(objectWithArea.area)")
} else {
print("222")
}
}
可选的协议要求
使用optional关键字来指定。
可选要求用在你需要和 Objective-C 打交道的代码中。协议和可选要求都必须带上 @objc 属性。标记 @objc 特性的协议只能被继承自 Objective-C 类的类或者 @objc 类遵循，其他类以及结构体和枚举均不能遵循这种协议。
使用可选要求时（例如，可选的方法或者属性），它们的类型会自动变成可选的。比如，一个类型为 (Int) -> String 的方法会变成 ((Int) -> String)?。需要注意的是整个函数类型是可选的，而不是函数的返回值。
@objc protocol CounterDataSource {
@objc optional func incre(count: Int) -> Int
@objc optional var fixedIncrement: Int { get }
}
协议扩展
协议可以通过扩展来为遵循协议的类型提供属性、方法以及下标的实现。可以基于协议来实现一些功能，而不用在遵守协议的每个类型中实现功能。
通过协议扩展，所有遵循协议的类型，都能自动获得这个扩展所增加的方法实现，无需任何额外修改。
如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中的默认实现被使用。
为协议扩展添加限制条件
在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 where 子句来描述。
extension Collection where Element: Equatable {
func allEqual() -> Bool {
for element in self {
if element != self.first {
return false
}
}
return true
}
}