格式
protocol SomeProtocol {
// protocol definition goes here
}
如果類有superclass，則將superclass寫在類后，然后接上protocol。
class SomeClass: SomeSuperclass, FirstProtocol, AnotherProtocol {
// class definition goes here
}
property in protocol
property在protocol中只定義類型和名字，并不規(guī)定是stored property還是computed property。
protocol中的property都是以var定義。
protocol SomeProtocol {
var mustBeSettable: Int { get set }
var doesNotNeedToBeSettable: Int { get }
}
如果在protocol中定義為gettable和settable，那么實現(xiàn)的時候就不能定義成一個constant stored property或者一個read-only property。如果protocol中定義的是gettable，那么就實現(xiàn)的時候可以根據(jù)自己需要決定是否定義成也settable的property。
type property都需要以static關(guān)鍵字定義。
protocol AnotherProtocol {
static var someTypeProperty: Int { get set }
}
method in protocol
instance method 和 type method都可以在protocol中定義，type method定義的時候需要以static修飾。
// type method
protocol SomeProtocol {
static func someTypeMethod()
}
// instance method
protocol RandomNumberGenerator {
func random() -> Double
}
如果需要在protocol的method中改變instance的值，需要用mutating修飾。例如：
protocol Togglable {
mutating func toggle()
}
如果你把一個protocol instance method標記為mutating，則在class中實現(xiàn)的時候就沒必要加mutating關(guān)鍵字了，但是enumration和structure還是需要加。例如：
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 is now equal to .on
initializer in protocol
定義的格式為：
protocol SomeProtocol {
init(someParameter: Int)
}
實現(xiàn)這個protocol的時候，需要在init前加required關(guān)鍵字。
class SomeClass: SomeProtocol {
required init(someParameter: Int) {
// initializer implementation goes here
}
}
由于final修飾的class是不可以被繼承的，所以final修飾的class在實現(xiàn)init方法的時候不需要加required。
如果子類在復(fù)寫一個父類的init方法的時候，恰巧這個init是從protocol中實現(xiàn)的，則需要使用required和override兩個關(guān)鍵字修飾。
protocol SomeProtocol {
init()
}
class SomeSuperClass {
init() {
// initializer implementation goes here
}
}
class SomeSubClass: SomeSuperClass, SomeProtocol {
// "required" from SomeProtocol conformance; "override" from SomeSuperClass
required override init() {
// initializer implementation goes here
}
}
protocols as types
由于protocol也是一種類型，所以protocol可以和其他類型一樣用在很多地方，比如：
可以作為參數(shù)類型或者function、method、initializer的返回值。
可以作為一個常量、變量或者property。
可以作為Array、dictionary或其他容器類型的內(nèi)容。
例如：
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
}
}
可以給generator賦值給任意實現(xiàn)了RandomNumberGenerator的instance。
protocol還可以用作代理，這點和oc中差不多，就不在多說了。
在class、enum或structure的extension中實現(xiàn)protocol
protocol TextRepresentable {
var textualDescription: String { get }
}
extension Dice: TextRepresentable {
var textualDescription: String {
return "A \(sides)-sided dice"
}
}
如果一個class、enumeration或者structure已經(jīng)實現(xiàn)了一個protocol的所有功能，只是沒有顯示的實現(xiàn)這個protocol，這時可以用一個empty extension來使其adopt這個protocol。
struct Hamster {
var name: String
var textualDescription: String {
return "A hamster named \(name)"
}
}
extension Hamster: TextRepresentable {}
protocol type的collection
上面說過protocol也是一種類型而且可以存儲在collection中，所以可以創(chuàng)建protocol類型的collection。
let things: [TextRepresentable] = [game, d12, simonTheHamster]
protocol inheritance
protocol可以被繼承，而且可以多繼承。
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// protocol definition goes here
}
class-only protocols
添加class關(guān)鍵字到protocol繼承列表的最前面，可以限制protocol只被class實現(xiàn)，而不被enumeration和structure實現(xiàn)。如下：
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// class-only protocol definition goes here
}
protocol composition
可以設(shè)定一個type同時遵守多個protocol，通過&符號將他們連接起來，例如：
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)
// Prints "Happy birthday, Malcolm, you're 21!"
protocol composition并沒有創(chuàng)建一個新的、永久性的protocol，而只是定義了一個臨時性的protocol把所有的requirement組合到一個protocol中。
checking for protocol conformance
根據(jù)前面的type cast中的介紹，這里同樣有is、as？、as！來作類型檢測和轉(zhuǎn)換，用法和之前一致，就不在介紹了。
optional protocol requirements
protocol可以定義為optioal，需要在被定義為optional的內(nèi)容前面加關(guān)鍵字optional,估計應(yīng)該是為了與oc兼容。格式如下：
@objc protocol CounterDataSource {
@objc optional func increment(forCount count: Int) -> Int
@objc optional var fixedIncrement: Int { get }
}
摘錄來自: Apple Inc. “The Swift Programming Language (Swift 3)”。 iBooks.
可以看到protocol定義前面和每個optional的method前面都用@objc修飾。
protocol extension
可以為protocol本身定義extension。格式為：
extension RandomNumberGenerator {
func randomBool() -> Bool {
return random() > 0.5
}
}
通過extension，我們可以為protocol中的computed property和method定義默認的實現(xiàn)，如果實現(xiàn)這個protocol的Type本身提供了自己的實現(xiàn)，則會覆蓋默認的實現(xiàn)。
extension PrettyTextRepresentable {
var prettyTextualDescription: String {
return textualDescription
}
}
我們還可以給protocol的extension添加條件約束，只有符合條件的conforming type才可以使用extension。例如：
extension Collection where Iterator.Element: TextRepresentable {
var textualDescription: String {
let itemsAsText = self.map { $0.textualDescription }
return "[" + itemsAsText.joined(separator: ", ") + "]"
}
}
使用如下：
let murrayTheHamster = Hamster(name: "Murray")
let morganTheHamster = Hamster(name: "Morgan")
let mauriceTheHamster = Hamster(name: "Maurice")
let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
//使用
print(hamsters.textualDescription)
// Prints "[A hamster named Murray, A hamster named Morgan, A hamster named Maurice]
如果一個confirming type對同一個method和property符合多個extensions約束，則swift會自動從這些extension中挑選一個最合適的選線。
