Swift編程語言中文教程（二十一）：Swift協(xié)議
本頁包含內(nèi)容：
- 協(xié)議的語法（Protocol Syntax）
- 屬性要求（Property Requirements）
- 方法要求（Method Requirements）
- 突變方法要求（Mutating Method Requirements）
- 協(xié)議類型（Protocols as Types）
- 委托(代理)模式（Delegation）
- 在擴(kuò)展中添加協(xié)議成員（Adding Protocol Conformance with an Extension）
- 通過擴(kuò)展補(bǔ)充協(xié)議聲明（Declaring Protocol Adoption with an Extension）
- 集合中的協(xié)議類型（Collections of Protocol Types）
- 協(xié)議的繼承（Protocol Inheritance）
- 協(xié)議合成（Protocol Composition）
- 檢驗協(xié)議的一致性（Checking for Protocol Conformance）
- 可選協(xié)議要求（Optional Protocol Requirements）
Protocol(協(xié)議)用于統(tǒng)一方法和屬性的名稱，而不實現(xiàn)任何功能。協(xié)議能夠被類，枚舉，結(jié)構(gòu)體實現(xiàn)，滿足協(xié)議要求的類，枚舉，結(jié)構(gòu)體被稱為協(xié)議的遵循者。
遵循者需要提供協(xié)議指定的成員，如屬性，方法，操作符，下標(biāo)等。
協(xié)議的語法
協(xié)議的定義與類，結(jié)構(gòu)體，枚舉的定義非常相似，如下所示：
protocol SomeProtocol {
// 協(xié)議內(nèi)容
}
在類，結(jié)構(gòu)體，枚舉的名稱后加上協(xié)議名稱，中間以冒號:分隔即可實現(xiàn)協(xié)議；實現(xiàn)多個協(xié)議時，各協(xié)議之間用逗號,分隔，如下所示：
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 結(jié)構(gòu)體內(nèi)容
}
當(dāng)某個類含有父類的同時并實現(xiàn)了協(xié)議，應(yīng)當(dāng)把父類放在所有的協(xié)議之前，如下所示：
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 類的內(nèi)容
}
屬性要求
協(xié)議能夠要求其遵循者必須含有一些特定名稱和類型的實例屬性(instance property)或類屬性 (type property)，也能夠要求屬性具有(設(shè)置權(quán)限)settable 和(訪問權(quán)限)gettable，但它不要求屬性是存儲型屬性(stored property)還是計算型屬性(calculate property)。
如果協(xié)議要求屬性具有設(shè)置權(quán)限和訪問權(quán)限，那常量存儲型屬性或者只讀計算型屬性都無法滿足此要求。如果協(xié)議只要求屬性具有訪問權(quán)限，那任何類型的屬性都可以滿足此要求，無論這些屬性是否具有設(shè)置權(quán)限。
通常前置var關(guān)鍵字將屬性聲明為變量。在屬性聲明后寫上{ get set }表示屬性為可讀寫的。{ get }用來表示屬性為可讀的。即使你為可讀的屬性實現(xiàn)了setter方法，它也不會出錯。
protocol SomeProtocol {
var musBeSettable : Int { get set }
var doesNotNeedToBeSettable: Int { get }
}
在協(xié)議中定義類屬性 (type property)時使用class前綴關(guān)鍵字，即使在結(jié)構(gòu)體或者枚舉中類屬性是要求使用static前綴關(guān)鍵字：
protocol AnotherProtocol {
class var someTypeProperty: Int { get set }
}
protocol FullyNamed {
var fullName: String { get }
}
FullyNamed協(xié)議含有fullName屬性。因此其遵循者必須含有一個名為fullName，類型為String的可讀屬性。
struct Person: FullyNamed{
var fullName: String
}
let john = Person(fullName: "John Appleseed")
//john.fullName 為 "John Appleseed"
Person結(jié)構(gòu)體含有一個名為fullName的存儲型屬性，完整的遵循了協(xié)議。(若協(xié)議未被完整遵循，編譯時則會報錯)。
如下所示，Startship類遵循了FullyNamed協(xié)議：
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實現(xiàn)為可讀的計算型屬性。它的每一個實例都有一個名為name的必備屬性和一個名為prefix的可選屬性。 當(dāng)prefix存在時，將prefix插入到name之前來為Starship構(gòu)建fullName。
方法要求
協(xié)議能夠要求其遵循者必備某些特定的實例方法和類方法。協(xié)議方法的聲明與普通方法聲明相似，但它不需要方法內(nèi)容。
注意： 協(xié)議方法支持變長參數(shù)(variadic parameter)，不支持默認(rèn)參數(shù)(default parameter)。
前置class關(guān)鍵字表示協(xié)議中的成員為類成員；當(dāng)協(xié)議用于被枚舉或結(jié)構(gòu)體遵循時，則使用static關(guān)鍵字。如下所示： 像類屬性的要求一樣，協(xié)議中定義類方法時也總是使用class關(guān)鍵字，即使類方法在枚舉或結(jié)構(gòu)體中實現(xiàn)時要求使用static關(guān)鍵字
protocol SomeProtocol {
class func someTypeMethod()
}
protocol RandomNumberGenerator {
func random() -> Double
}
RandomNumberGenerator協(xié)議要求其遵循者必須擁有一個名為random， 返回值類型為Double的實例方法。(我們假設(shè)隨機(jī)數(shù)在[0，1]區(qū)間內(nèi))。
LinearCongruentialGenerator類遵循了RandomNumberGenerator協(xié)議，并提供了一個叫做線性同余生成器(linear congruential generator)的偽隨機(jī)數(shù)算法。
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"
突變方法要求
能在方法或函數(shù)內(nèi)部改變實例類型的方法稱為突變方法。在值類型(Value Type)(譯者注：特指結(jié)構(gòu)體和枚舉)中的的函數(shù)前綴加上mutating關(guān)鍵字來表示該函數(shù)允許改變該實例和其屬性的類型。 這一變換過程在實例方法(Instance Methods)章節(jié)中有詳細(xì)描述。
(譯者注：類中的成員為引用類型(Reference Type)，可以方便的修改實例及其屬性的值而無需改變類型；而結(jié)構(gòu)體和枚舉中的成員均為值類型(Value Type)，修改變量的值就相當(dāng)于修改變量的類型，而Swift默認(rèn)不允許修改類型，因此需要前置mutating關(guān)鍵字用來表示該函數(shù)中能夠修改類型)
注意： 用class實現(xiàn)協(xié)議中的mutating方法時，不用寫mutating關(guān)鍵字；用結(jié)構(gòu)體，枚舉實現(xiàn)協(xié)議中的mutating方法時，必須寫mutating關(guān)鍵字。
如下所示，Togglable協(xié)議含有toggle函數(shù)。根據(jù)函數(shù)名稱推測，toggle可能用于切換或恢復(fù)某個屬性的狀態(tài)。mutating關(guān)鍵字表示它為突變方法：
protocol Togglable {
mutating func toggle()
}
當(dāng)使用枚舉或結(jié)構(gòu)體來實現(xiàn)Togglabl協(xié)議時，必須在toggle方法前加上mutating關(guān)鍵字。
如下所示，OnOffSwitch枚舉遵循了Togglable協(xié)議，On，Off兩個成員用于表示當(dāng)前狀態(tài)
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 現(xiàn)在的值為 .On
協(xié)議類型
協(xié)議本身不實現(xiàn)任何功能，但你可以將它當(dāng)做類型來使用。
使用場景：
- 作為函數(shù)，方法或構(gòu)造器中的參數(shù)類型，返回值類型
- 作為常量，變量，屬性的類型
- 作為數(shù)組，字典或其他容器中的元素類型
注意： 協(xié)議類型應(yīng)與其他類型(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兩個屬性，前者用來表示骰子有幾個面，后者為骰子提供一個隨機(jī)數(shù)生成器。由于后者為RandomNumberGenerator的協(xié)議類型。所以它能夠被賦值為任意遵循該協(xié)議的類型。
此外，使用構(gòu)造器(init)來代替之前版本中的setup操作。構(gòu)造器中含有一個名為generator，類型為RandomNumberGenerator的形參，使得它可以接收任意遵循RandomNumberGenerator協(xié)議的類型。
roll方法用來模擬骰子的面值。它先使用generator的random方法來創(chuàng)建一個[0-1]區(qū)間內(nèi)的隨機(jī)數(shù)種子，然后加工這個隨機(jī)數(shù)種子生成骰子的面值。
如下所示，LinearCongruentialGenerator的實例作為隨機(jī)數(shù)生成器傳入Dice的構(gòu)造器
var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
for _ in 1...5 {
println("Random dice roll is \(d6.roll())")
}
//輸出結(jié)果
//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
委托(代理)模式
委托是一種設(shè)計模式，它允許類或結(jié)構(gòu)體將一些需要它們負(fù)責(zé)的功能交由(委托)給其他的類型。
委托模式的實現(xiàn)很簡單： 定義協(xié)議來封裝那些需要被委托的函數(shù)和方法， 使其遵循者擁有這些被委托的函數(shù)和方法。
委托模式可以用來響應(yīng)特定的動作或接收外部數(shù)據(jù)源提供的數(shù)據(jù)，而無需要知道外部數(shù)據(jù)源的類型。
下文是兩個基于骰子游戲的協(xié)議：
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協(xié)議可以在任意含有骰子的游戲中實現(xiàn)，DiceGameDelegate協(xié)議可以用來追蹤DiceGame的游戲過程。
如下所示，SnakesAndLadders是Snakes and Ladders(譯者注：控制流章節(jié)有該游戲的詳細(xì)介紹)游戲的新版本。新版本使用Dice作為骰子，并且實現(xiàn)了DiceGame和DiceGameDelegate協(xié)議
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)
}
}
游戲的初始化設(shè)置(setup)被SnakesAndLadders類的構(gòu)造器(initializer)實現(xiàn)。所有的游戲邏輯被轉(zhuǎn)移到了play方法中。
注意： 因為delegate并不是該游戲的必備條件，delegate被定義為遵循DiceGameDelegate協(xié)議的可選屬性
DicegameDelegate協(xié)議提供了三個方法用來追蹤游戲過程。被放置于游戲的邏輯中，即play()方法內(nèi)。分別在游戲開始時，新一輪開始時，游戲結(jié)束時被調(diào)用。
因為delegate是一個遵循DiceGameDelegate的可選屬性，因此在play()方法中使用了可選鏈來調(diào)用委托方法。 若delegate屬性為nil， 則委托調(diào)用優(yōu)雅地失效。若delegate不為nil，則委托方法被調(diào)用
如下所示，DiceGameTracker遵循了DiceGameDelegate協(xié)議
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實現(xiàn)了DiceGameDelegate協(xié)議的方法要求，用來記錄游戲已經(jīng)進(jìn)行的輪數(shù)。 當(dāng)游戲開始時，numberOfTurns屬性被賦值為0；在每新一輪中遞加；游戲結(jié)束后，輸出打印游戲的總輪數(shù)。
gameDidStart方法從game參數(shù)獲取游戲信息并輸出。game在方法中被當(dāng)做DiceGame類型而不是SnakeAndLadders類型，所以方法中只能訪問DiceGame協(xié)議中的成員。
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
在擴(kuò)展中添加協(xié)議成員
即便無法修改源代碼，依然可以通過擴(kuò)展(Extension)來擴(kuò)充已存在類型(譯者注： 類，結(jié)構(gòu)體，枚舉等)。擴(kuò)展可以為已存在的類型添加屬性，方法，下標(biāo)，協(xié)議等成員。詳情請在擴(kuò)展章節(jié)中查看。
注意： 通過擴(kuò)展為已存在的類型遵循協(xié)議時，該類型的所有實例也會隨之添加協(xié)議中的方法
TextRepresentable協(xié)議含有一個asText，如下所示：
protocol TextRepresentable {
func asText() -> String
}
通過擴(kuò)展為上一節(jié)中提到的Dice類遵循TextRepresentable協(xié)議
extension Dice: TextRepresentable {
cun asText() -> String {
return "A \(sides)-sided dice"
}
}
從現(xiàn)在起，Dice類型的實例可被當(dāng)作TextRepresentable類型：
let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator()) println(d12.asText()) // 輸出 "A 12-sided dice"
SnakesAndLadders類也可以通過擴(kuò)展的方式來遵循協(xié)議：
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"
通過擴(kuò)展補(bǔ)充協(xié)議聲明
當(dāng)一個類型已經(jīng)實現(xiàn)了協(xié)議中的所有要求，卻沒有聲明時，可以通過擴(kuò)展來補(bǔ)充協(xié)議聲明：
struct Hamster {
var name: String
func asText() -> String {
return "A hamster named \(name)"
}
}
extension Hamster: TextRepresentabl {}
從現(xiàn)在起，Hamster的實例可以作為TextRepresentable類型使用
let simonTheHamster = Hamster(name: "Simon") let somethingTextRepresentable: TextRepresentabl = simonTheHamester println(somethingTextRepresentable.asText()) // 輸出 "A hamster named Simon"
注意： 即時滿足了協(xié)議的所有要求，類型也不會自動轉(zhuǎn)變，因此你必須為它做出明顯的協(xié)議聲明
集合中的協(xié)議類型
協(xié)議類型可以被集合使用，表示集合中的元素均為協(xié)議類型：
let things: TextRepresentable[] = [game,d12,simoTheHamster]
如下所示，things數(shù)組可以被直接遍歷，并調(diào)用其中元素的asText()函數(shù)：
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被當(dāng)做是TextRepresentable類型而不是Dice，DiceGame，Hamster等類型。因此能且僅能調(diào)用asText方法
協(xié)議的繼承
協(xié)議能夠繼承一到多個其他協(xié)議。語法與類的繼承相似，多個協(xié)議間用逗號,分隔
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 協(xié)議定義
}
如下所示，PrettyTextRepresentable協(xié)議繼承了TextRepresentable協(xié)議
protocol PrettyTextRepresentable: TextRepresentable {
func asPrettyText() -> String
}
遵循``PrettyTextRepresentable協(xié)議的同時，也需要遵循TextRepresentable`協(xié)議。
如下所示，用擴(kuò)展為SnakesAndLadders遵循PrettyTextRepresentable協(xié)議：
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數(shù)組中的每一個元素：
- 當(dāng)從數(shù)組中迭代出的元素的值大于0時，用▲表示
- 當(dāng)從數(shù)組中迭代出的元素的值小于0時，用▼表示
- 當(dāng)從數(shù)組中迭代出的元素的值等于0時，用○表示
任意SankesAndLadders的實例都可以使用asPrettyText()方法。
println(game.asPrettyText()) // A game of Snakes and Ladders with 25 squares: // ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
協(xié)議合成
一個協(xié)議可由多個協(xié)議采用protocol<SomeProtocol, AnotherProtocol>這樣的格式進(jìn)行組合，稱為協(xié)議合成(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協(xié)議包含String類型的name屬性；Aged協(xié)議包含Int類型的age屬性。Person結(jié)構(gòu)體遵循了這兩個協(xié)議。
wishHappyBirthday函數(shù)的形參celebrator的類型為protocol<Named,Aged>。可以傳入任意遵循這兩個協(xié)議的類型的實例
注意： 協(xié)議合成并不會生成一個新協(xié)議類型，而是將多個協(xié)議合成為一個臨時的協(xié)議，超出范圍后立即失效。
檢驗協(xié)議的一致性
使用is檢驗協(xié)議一致性，使用as將協(xié)議類型向下轉(zhuǎn)換(downcast)為的其他協(xié)議類型。檢驗與轉(zhuǎn)換的語法和之前相同(詳情查看類型檢查)：
- is操作符用來檢查實例是否遵循了某個協(xié)議。
- as?返回一個可選值，當(dāng)實例遵循協(xié)議時，返回該協(xié)議類型；否則返回nil
- as用以強(qiáng)制向下轉(zhuǎn)換型。
@objc protocol HasArea {
var area: Double { get }
}
注意： @objc用來表示協(xié)議是可選的，也可以用來表示暴露給Objective-C的代碼，此外，@objc型協(xié)議只對類有效，因此只能在類中檢查協(xié)議的一致性。詳情查看。
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協(xié)議，前者把a(bǔ)rea寫為計算型屬性（computed property），后者則把a(bǔ)rea寫為存儲型屬性（stored property）。
如下所示，Animal類沒有實現(xiàn)任何協(xié)議
class Animal {
var legs: Int
init(legs: Int) { self.legs = legs }
}
Circle,Country,Animal并沒有一個相同的基類，所以采用AnyObject類型的數(shù)組來裝載在它們的實例，如下所示：
let objects: AnyObject[] = [
Circle(radius: 2.0),
Country(area: 243_610),
Animal(legs: 4)
]
如下所示，在迭代時檢查object數(shù)組的元素是否遵循了HasArea協(xié)議：
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
當(dāng)數(shù)組中的元素遵循HasArea協(xié)議時，通過as?操作符將其可選綁定(optional binding)到objectWithArea常量上。
objects數(shù)組中元素的類型并不會因為向下轉(zhuǎn)型而改變，當(dāng)它們被賦值給objectWithArea時只被視為HasArea類型，因此只有area屬性能夠被訪問。
可選協(xié)議要求
可選協(xié)議含有可選成員，其遵循者可以選擇是否實現(xiàn)這些成員。在協(xié)議中使用@optional關(guān)鍵字作為前綴來定義可選成員。
可選協(xié)議在調(diào)用時使用可選鏈，詳細(xì)內(nèi)容在可選鏈章節(jié)中查看。
像someOptionalMethod?(someArgument)一樣，你可以在可選方法名稱后加上?來檢查該方法是否被實現(xiàn)。可選方法和可選屬性都會返回一個可選值(optional value)，當(dāng)其不可訪問時，?之后語句不會執(zhí)行，并返回nil。
注意： 可選協(xié)議只能在含有@objc前綴的協(xié)議中生效。且@objc的協(xié)議只能被類遵循。
Counter類使用CounterDataSource類型的外部數(shù)據(jù)源來提供增量值(increment amount)，如下所示：
@objc protocol CounterDataSource {
@optional func incrementForCount(count: Int) -> Int
@optional var fixedIncrement: Int { get }
}
CounterDataSource含有incrementForCount的可選方法和fiexdIncrement的可選屬性。
注意： CounterDataSource中的屬性和方法都是可選的，因此可以在類中聲明但不實現(xiàn)這些成員，盡管技術(shù)上允許這樣做，不過最好不要這樣寫。
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屬性用于存儲當(dāng)前的值，increment方法用來為count賦值。
increment方法通過可選鏈，嘗試從兩種可選成員中獲取count。
- 由于dataSource可能為nil，因此在dataSource后邊加上了?標(biāo)記來表明只在dataSource非空時才去調(diào)用incrementForCount`方法。
- 即使dataSource存在，但是也無法保證其是否實現(xiàn)了incrementForCount方法，因此在incrementForCount方法后邊也加有?標(biāo)記。
在調(diào)用incrementForCount方法后，Int型可選值通過可選綁定(optional binding)自動拆包并賦值給常量amount。
當(dāng)incrementForCount不能被調(diào)用時，嘗試使用可選屬性``fixedIncrement來代替。
ThreeSource實現(xiàn)了CounterDataSource協(xié)議，如下所示：
class ThreeSource: CounterDataSource {
let fixedIncrement = 3
}
使用ThreeSource作為數(shù)據(jù)源開實例化一個Counter：
var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
counter.increment()
println(counter.count)
}
// 3
// 6
// 9
// 12
TowardsZeroSource實現(xiàn)了CounterDataSource協(xié)議中的incrementForCount方法，如下所示：
class TowardsZeroSource: CounterDataSource {
func incrementForCount(count: Int) -> Int {
if count == 0 {
return 0
} else if count < 0 {
return 1
} else {
return -1
}
}
}
下邊是執(zhí)行的代碼：
counter.count = -4
counter.dataSource = TowardsZeroSource()
for _ in 1...5 {
counter.increment()
println(counter.count)
}
// -3
// -2
// -1
// 0
// 0
QQ交談
在線咨詢
渝公網(wǎng)安備
50010702500608號
客服熱線