swift中的協議

Protocol(協議)用於統一方法和屬性的名稱，而不實現任何功能。協議可以被類，枚舉，結構體實現，知足協議要求的類，枚舉，結構體被稱爲協議的遵循者。

遵循者須要提供協議指定的成員，如屬性，方法，操做符，下標等。

協議的語法

協議的定義與類，結構體，枚舉的定義很是類似，以下所示：

protocol SomeProtocol { // 協議內容 }

在類，結構體，枚舉的名稱後加上協議名稱，中間以冒號:分隔便可實現協議；實現多個協議時，各協議之間用逗號,分隔，以下所示：

struct SomeStructure: FirstProtocol, AnotherProtocol { // 結構體內容 }

當某個類含有父類的同時並實現了協議，應當把父類放在全部的協議以前，以下所示：

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { // 類的內容 }

屬性要求

協議可以要求其遵循者必須含有一些特定名稱和類型的實例屬性(instance property)或類屬性 (type property)，也可以要求屬性的(設置權限)settable 和(訪問權限)gettable，但它不要求屬性是存儲型屬性(stored property)仍是計算型屬性(calculate property)。

一般前置var關鍵字將屬性聲明爲變量。在屬性聲明後寫上{ get set }表示屬性爲可讀寫的。{ get }用來表示屬性爲可讀的。即便你爲可讀的屬性實現了setter方法，它也不會出錯。

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

用類來實現協議時，使用class關鍵字來表示該屬性爲類成員；用結構體或枚舉實現協議時，則使用static關鍵字來表示：

protocol AnotherProtocol { class var someTypeProperty: Int { get set } } protocol FullyNamed { var fullName: String { get } }

FullyNamed協議含有fullName屬性。所以其遵循者必須含有一個名爲fullName，類型爲String的可讀屬性。

struct Person: FullyNamed{ var fullName: String } let john = Person(fullName: "John Appleseed") //john.fullName 爲 "John Appleseed"

Person結構體含有一個名爲fullName的存儲型屬性，完整的遵循了協議。(若協議未被完整遵循，編譯時則會報錯)。

以下所示，Startship類遵循了FullyNamed協議：

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

Starship類將fullName實現爲可讀的計算型屬性。它的每個實例都有一個名爲name的必備屬性和一個名爲prefix的可選屬性。 當prefix存在時，將prefix插入到name以前來爲Starship構建fullName。

方法要求

協議可以要求其遵循者必備某些特定的實例方法和類方法。協議方法的聲明與普通方法聲明類似，但它不須要方法內容。

注意：

協議方法支持變長參數(variadic parameter)，不支持默認參數(default parameter)。

前置class關鍵字表示協議中的成員爲類成員；當協議用於被枚舉或結構體遵循時，則使用static關鍵字。以下所示：

protocol SomeProtocol { class func someTypeMethod() } protocol RandomNumberGenerator { func random() -> Double }

RandomNumberGenerator協議要求其遵循者必須擁有一個名爲random， 返回值類型爲Double的實例方法。(咱們假設隨機數在[0，1]區間內)。

LinearCongruentialGenerator類遵循了RandomNumberGenerator協議，並提供了一個叫作線性同餘生成器(linear congruential generator)的僞隨機數算法。

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() println("Here's a random number: \(generator.random())") // 輸出 : "Here's a random number: 0.37464991998171" println("And another one: \(generator.random())") // 輸出 : "And another one: 0.729023776863283"

突變方法要求

能在方法或函數內部改變實例類型的方法稱爲突變方法。在值類型(Value Type)(譯者注：特指結構體和枚舉)中的的函數前綴加上mutating關鍵字來表示該函數容許改變該實例和其屬性的類型。 這一變換過程在實例方法(Instance Methods)章節中有詳細描述。

(譯者注：類中的成員爲引用類型(Reference Type)，能夠方便的修改實例及其屬性的值而無需改變類型；而結構體和枚舉中的成員均爲值類型(Value Type)，修改變量的值就至關於修改變量的類型，而Swift默認不容許修改類型，所以須要前置mutating關鍵字用來表示該函數中可以修改類型)

注意：

用class實現協議中的mutating方法時，不用寫mutating關鍵字；用結構體，枚舉實現協議中的mutating方法時，必須寫mutating關鍵字。

以下所示，Togglable協議含有toggle函數。根據函數名稱推測，toggle可能用於切換或恢復某個屬性的狀態。mutating關鍵字表示它爲突變方法：

protocol Togglable { mutating func toggle() }

當使用枚舉或結構體來實現Togglabl協議時，必須在toggle方法前加上mutating關鍵字。

以下所示，OnOffSwitch枚舉遵循了Togglable協議，On，Off兩個成員用於表示當前狀態

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

協議類型

協議自己不實現任何功能，但你能夠將它當作類型來使用。

使用場景：

• 做爲函數，方法或構造器中的參數類型，返回值類型
• 做爲常量，變量，屬性的類型
• 做爲數組，字典或其餘容器中的元素類型

注意：

協議類型應與其餘類型(Int，Double，String)的寫法相同，使用駝峯式

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兩個屬性，前者用來表示骰子有幾個面，後者爲骰子提供一個隨機數生成器。因爲後者爲RandomNumberGenerator的協議類型。因此它可以被賦值爲任意遵循該協議的類型。

此外，使用構造器(init)來代替以前版本中的setup操做。構造器中含有一個名爲generator，類型爲RandomNumberGenerator的形參，使得它能夠接收任意遵循RandomNumberGenerator協議的類型。

roll方法用來模擬骰子的面值。它先使用generator的random方法來建立一個[0-1]區間內的隨機數種子，而後加工這個隨機數種子生成骰子的面值。

以下所示，LinearCongruentialGenerator的實例做爲隨機數生成器傳入Dice的構造器

var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator()) for _ in 1...5 { println("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

委託(代理)模式

委託是一種設計模式，它容許類或結構體將一些須要它們負責的功能交由(委託)給其餘的類型。

委託模式的實現很簡單： 定義協議來封裝那些須要被委託的函數和方法， 使其遵循者擁有這些被委託的函數和方法。

委託模式能夠用來響應特定的動做或接收外部數據源提供的數據，而無須要知道外部數據源的類型。

下文是兩個基於骰子游戲的協議：

protocol DiceGame { var dice: Dice { get } func play() } protocol DiceGameDelegate { func gameDidStart(game: DiceGame) func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int) func gameDidEnd(game: DiceGame) }

DiceGame協議能夠在任意含有骰子的遊戲中實現，DiceGameDelegate協議能夠用來追蹤DiceGame的遊戲過程。

以下所示，SnakesAndLadders是Snakes and Ladders(譯者注：控制流章節有該遊戲的詳細介紹)遊戲的新版本。新版本使用Dice做爲骰子，而且實現了DiceGame和DiceGameDelegate協議

class SnakesAndLadders: DiceGame { let finalSquare = 25 let dic = Dice(sides: 6, generator: LinearCongruentialGenerator()) var square = 0 var board: Int[] init() { board = Int[](count: finalSquare + 1, repeatedValue: 0) board[03] = +08; board[06] = +11; borad[09] = +09; board[10] = +02 borad[14] = -10; board[19] = -11; borad[22] = -02; board[24] = -08 } var delegate: DiceGameDelegate? func play() { square = 0 delegate?.gameDidStart(self) gameLoop: while square != finalSquare { let diceRoll = dice.roll() delegate?.game(self,didStartNewTurnWithDiceRoll: diceRoll) switch square + diceRoll { case finalSquare: break gameLoop case let newSquare where newSquare > finalSquare: continue gameLoop default: square += diceRoll square += board[square] } } delegate?.gameDIdEnd(self) } }

遊戲的初始化設置(setup)被SnakesAndLadders類的構造器(initializer)實現。全部的遊戲邏輯被轉移到了play方法中。

注意：

由於delegate並非該遊戲的必備條件，delegate被定義爲遵循DiceGameDelegate協議的可選屬性

DicegameDelegate協議提供了三個方法用來追蹤遊戲過程。被放置於遊戲的邏輯中，即play()方法內。分別在遊戲開始時，新一輪開始時，遊戲結束時被調用。

由於delegate是一個遵循DiceGameDelegate的可選屬性，所以在play()方法中使用了可選鏈來調用委託方法。 若delegate屬性爲nil， 則委託調用優雅地失效。若delegate不爲nil，則委託方法被調用

以下所示，DiceGameTracker遵循了DiceGameDelegate協議

class DiceGameTracker: DiceGameDelegate { var numberOfTurns = 0 func gameDidStart(game: DiceGame) { numberOfTurns = 0 if game is SnakesAndLadders { println("Started a new game of Snakes and Ladders") } println("The game is using a \(game.dice.sides)-sided dice") } func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) { ++numberOfTurns println("Rolled a \(diceRoll)") } func gameDidEnd(game: DiceGame) { println("The game lasted for \(numberOfTurns) turns") } }

DiceGameTracker實現了DiceGameDelegate協議的方法要求，用來記錄遊戲已經進行的輪數。 當遊戲開始時，numberOfTurns屬性被賦值爲0；在每新一輪中遞加；遊戲結束後，輸出打印遊戲的總輪數。

gameDidStart方法從game參數獲取遊戲信息並輸出。game在方法中被當作DiceGame類型而不是SnakeAndLadders類型，因此方法中只能訪問DiceGame協議中的成員。

DiceGameTracker的運行狀況，以下所示：

「let tracker = DiceGameTracker() let game = SnakesAndLadders() game.delegate = tracker game.play() // Started a new game of Snakes and Ladders // The game is using a 6-sided dice // Rolled a 3 // Rolled a 5 // Rolled a 4 // Rolled a 5 // The game lasted for 4 turns」

在擴展中添加協議成員

即使沒法修改源代碼，依然能夠經過擴展(Extension)來擴充已存在類型(譯者注： 類，結構體，枚舉等)。擴展能夠爲已存在的類型添加屬性，方法，下標，協議等成員。詳情請在擴展章節中查看。

注意：

經過擴展爲已存在的類型遵循協議時，該類型的全部實例也會隨之添加協議中的方法

TextRepresentable協議含有一個asText，以下所示：

protocol TextRepresentable { func asText() -> String }

經過擴展爲上一節中提到的Dice類遵循TextRepresentable協議

extension Dice: TextRepresentable { cun asText() -> String { return "A \(sides)-sided dice" } }

從如今起，Dice類型的實例可被看成TextRepresentable類型：

let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator()) println(d12.asText()) // 輸出 "A 12-sided dice"

SnakesAndLadders類也能夠經過擴展的方式來遵循協議：

extension SnakeAndLadders: TextRepresentable { func asText() -> String { return "A game of Snakes and Ladders with \(finalSquare) squares" } } println(game.asText()) // 輸出 "A game of Snakes and Ladders with 25 squares"

經過延展補充協議聲明

當一個類型已經實現了協議中的全部要求，卻沒有聲明時，能夠經過擴展來補充協議聲明：

struct Hamster { var name: String func asText() -> String { return "A hamster named \(name)" } } extension Hamster: TextRepresentabl {}

從如今起，Hamster的實例能夠做爲TextRepresentable類型使用

let simonTheHamster = Hamster(name: "Simon") let somethingTextRepresentable: TextRepresentabl = simonTheHamester println(somethingTextRepresentable.asText()) // 輸出 "A hamster named Simon"

注意：

即時知足了協議的全部要求，類型也不會自動轉變，所以你必須爲它作出明顯的協議聲明

集合中的協議類型

協議類型能夠被集合使用，表示集合中的元素均爲協議類型：

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

以下所示，things數組能夠被直接遍歷，並調用其中元素的asText()函數：

for thing in things { println(thing.asText()) } // A game of Snakes and Ladders with 25 squares // A 12-sided dice // A hamster named Simon

thing被當作是TextRepresentable類型而不是Dice，DiceGame，Hamster等類型。所以能且僅能調用asText方法

協議的繼承

協議可以繼承一到多個其餘協議。語法與類的繼承類似，多個協議間用逗號,分隔

protocol InheritingProtocol: SomeProtocol, AnotherProtocol { // 協議定義 }

以下所示，PrettyTextRepresentable協議繼承了TextRepresentable協議

protocol PrettyTextRepresentable: TextRepresentable { func asPrettyText() -> String }

遵循``PrettyTextRepresentable協議的同時，也須要遵循TextRepresentable`協議。

以下所示，用擴展爲SnakesAndLadders遵循PrettyTextRepresentable協議：

extension SnakesAndLadders: PrettyTextRepresentable { func asPrettyText() -> String { var output = asText() + ":\n" for index in 1...finalSquare { switch board[index] { case let ladder where ladder > 0: output += "▲ " case let snake where snake < 0: output += "▼ " default: output += "○ " } } return output } }

在for in中迭代出了board數組中的每個元素：

• 當從數組中迭代出的元素的值大於0時，用▲表示
• 當從數組中迭代出的元素的值小於0時，用▼表示
• 當從數組中迭代出的元素的值等於0時，用○表示

任意SankesAndLadders的實例均可以使用asPrettyText()方法。

println(game.asPrettyText()) // A game of Snakes and Ladders with 25 squares: // ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○

協議合成

一個協議可由多個協議採用protocol<SomeProtocol, AnotherProtocol>這樣的格式進行組合，稱爲協議合成(protocol composition)。

舉個例子：

protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } struct Person: Named, Aged { var name: String var age: Int } func wishHappyBirthday(celebrator: protocol<Named, Aged>) { println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!") } let birthdayPerson = Person(name: "Malcolm", age: 21) wishHappyBirthday(birthdayPerson) // 輸出 "Happy birthday Malcolm - you're 21!

Named協議包含String類型的name屬性；Aged協議包含Int類型的age屬性。Person結構體遵循了這兩個協議。

wishHappyBirthday函數的形參celebrator的類型爲protocol<Named,Aged>。能夠傳入任意遵循這兩個協議的類型的實例

注意：

協議合成並不會生成一個新協議類型，而是將多個協議合成爲一個臨時的協議，超出範圍後當即失效。

檢驗協議的一致性

使用is檢驗協議一致性，使用as將協議類型向下轉換(downcast)爲的其餘協議類型。檢驗與轉換的語法和以前相同(詳情查看類型檢查)：

• is操做符用來檢查實例是否遵循了某個協議。
• as?返回一個可選值，當實例遵循協議時，返回該協議類型；不然返回nil
• as用以強制向下轉換型。

@objc protocol HasArea { var area: Double { get } }

注意：

@objc用來表示協議是可選的，也能夠用來表示暴露給Objective-C的代碼，此外，@objc型協議只對類有效，所以只能在類中檢查協議的一致性。詳情查看Using Siwft with Cocoa and Objectivei-c。

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

Circle和Country都遵循了HasArea協議，前者把area寫爲計算型屬性（computed property），後者則把area寫爲存儲型屬性（stored property）。

以下所示，Animal類沒有實現任何協議

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) ]

以下所示，在迭代時檢查object數組的元素是否遵循了HasArea協議：

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

當數組中的元素遵循HasArea協議時，經過as?操做符將其可選綁定(optional binding)到objectWithArea常量上。

objects數組中元素的類型並不會由於向下轉型而改變，當它們被賦值給objectWithArea時只被視爲HasArea類型，所以只有area屬性可以被訪問。

可選協議要求

可選協議含有可選成員，其遵循者能夠選擇是否實現這些成員。在協議中使用@optional關鍵字做爲前綴來定義可選成員。

可選協議在調用時使用可選鏈，詳細內容在可選鏈章節中查看。

像someOptionalMethod?(someArgument)同樣，你能夠在可選方法名稱後加上?來檢查該方法是否被實現。可選方法和可選屬性都會返回一個可選值(optional value)，當其不可訪問時，?以後語句不會執行，並返回nil。

注意：

可選協議只能在含有@objc前綴的協議中生效。且@objc的協議只能被類遵循。

Counter類使用CounterDataSource類型的外部數據源來提供增量值(increment amount)，以下所示：

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

CounterDataSource含有incrementForCount的可選方法和fiexdIncrement的可選屬性。

注意：

CounterDataSource中的屬性和方法都是可選的，所以能夠在類中聲明但不實現這些成員，儘管技術上容許這樣作，不過最好不要這樣寫。

Counter類含有CounterDataSource?類型的可選屬性dataSource，以下所示：

@objc 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 } } }

count屬性用於存儲當前的值，increment方法用來爲count賦值。

increment方法經過可選鏈，嘗試從兩種可選成員中獲取count。

1. 因爲dataSource可能爲nil，所以在dataSource後邊加上了?標記來代表只在dataSource非空時纔去調用incrementForCount`方法。
2. 即便dataSource存在，可是也沒法保證其是否實現了incrementForCount方法，所以在incrementForCount方法後邊也加有?標記。

在調用incrementForCount方法後，Int型可選值經過可選綁定(optional binding)自動拆包並賦值給常量amount。

當incrementForCount不能被調用時，嘗試使用可選屬性``fixedIncrement來代替。

ThreeSource實現了CounterDataSource協議，以下所示：

class ThreeSource: CounterDataSource { let fixedIncrement = 3 }

使用ThreeSource做爲數據源開實例化一個Counter：

var counter = Counter() counter.dataSource = ThreeSource() for _ in 1...4 { counter.increment() println(counter.count) } // 3 // 6 // 9 // 12

TowardsZeroSource實現了CounterDataSource協議中的incrementForCount方法，以下所示：

class TowardsZeroSource: CounterDataSource { func incrementForCount(count: Int) -> Int { if count == 0 { return 0 } else if count < 0 { return 1 } else { return -1 } } }

下邊是執行的代碼：

counter.count = -4 counter.dataSource = TowardsZeroSource() for _ in 1...5 { counter.increment() println(counter.count) } // -3 // -2 // -1 // 0 // 0