Swift学习第八枪--协议（二）

ゝ一世哀愁。 2022-08-22 15:18 194阅读 0赞

# 协议（二） #

下面是我的新建的Swift学习交流群，欢迎大家一起来共同学习Swift。  
![这里写图片描述][20160603213258019]

这篇紧接着前面的协议（一）继续总结。

## 1.委托(代理)模式 ##

委托是一种设计模式，它允许 类 或 结构体 将一些需要它们负责的功能 交由(委托) 给其他的类型的实例。委托模式的实现很简单: 定义协议来封装那些需要被委托的函数和方法， 使其 遵循者 拥有这些被委托的 函数和方  
法 。委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型信息。

下面的例子是两个基于骰子游戏的协议:

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 (Control Flow章节有该游戏的详细介绍)游戏的新版本。新版本使用 Dice 作为骰子，并且实现了 DiceGame 和 DiceGameDelegate 协议，后者用来记录游戏的过程:

class SnakesAndLadders: DiceGame {
    let finalSquare = 25
    let dice = 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; board[09] = +09; board[10] = +02
    board[14] = -10; board[19] = -11; board[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)
    }
    }

这个版本的游戏封装到了 SnakesAndLadders 类中，该类遵循了 DiceGame 协议，并且提供了相应的可读的 dice 属性和 play 实例方法。( dice 属性在构造之后就不再改变，且协议只要求 dice 为只读的，因此将 dice 声明为常量属性。)

游戏使用 SnakesAndLadders 类的 构造器(initializer) 初始化游戏。所有的游戏逻辑被转移到了协议中的 play方法， play 方法使用协议规定的 dice 属性提供骰子摇出的值。

注意: delegate 并不是游戏的必备条件，因此 delegate 被定义为遵循 DiceGameDelegate 协议的可选属性。因  
为 delegate 是可选值，因此在初始化的时候被自动赋值为 nil 。随后，可以在游戏中为 delegate 设置适当的值。

DicegameDelegate 协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即 play() 方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。

因为 delegate 是一个遵循 DiceGameDelegate 的可选属性，因此在 play() 方法中使用了 可选链 来调用委托方法。 若 delegate 属性为 nil ， 则delegate所调用的方法失效，并不会产生错误。若 delegate 不为 nil ，则方法能够被调用。如下所示， DiceGameTracker 遵循了 DiceGameDelegate 协议

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

DiceGameTracker 实现了 DiceGameDelegate 协议规定的三个方法，用来记录游戏已经进行的轮数。 当游戏开始时， numberOfTurns 属性被赋值为0; 在每新一轮中递增; 游戏结束后，输出打印游戏的总轮数。

gameDidStart 方法从 game 参数获取游戏信息并输出。 game 在方法中被当做 DiceGame 类型而不是 SnakeAndLadders 类型，所以方法中只能访问 DiceGame 协议中的成员。当然了，这些方法也可以在类型转换之后  
调用。在上例代码中，通过 is 操作符检查 game 是否SnakesAndLadders 类型的实例，如果是，则打印出相应的内容。

无论当前进行的是何种游戏， game 都遵循 DiceGame 协议以确保 game 含有 dice 属性，因此在 gameDidStart(\_:) 方法中可以通过传入的 game 参数来访问 dice 属性，进而打印出 dice 的 sides 属性的值。  
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

## 2.在扩展中添加协议成员 ##

即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(类，结构体，枚举等 )。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。

注意：  
通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法。例如 TextRepresentable 协议，任何想要表示一些文本内容的类型都可以遵循该协议。这些想要表示的内容可以是类型本身的描述，也可以是当前内容的版本:

protocol TextRepresentable {
    func asText() -> String
    }

可以通过扩展，为上一节中提到的 Dice 增加类遵循TextRepresentable 协议的功能

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

现在，通过扩展使得 Dice 类型遵循了一个新的协议，这和 Dice 类型在定义的时候声明为遵循 TextRepresentable 协议的效果相同。在扩展的时候，协议名称写在类型名之后，以冒号隔开，在大括号内写明新添加的协议内容。  
现在所有 Dice 的实例都遵循了 TextRepresentable 协议:

let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
    print(d12.asText())
    // 输出 "A 12-sided dice"
    同样 SnakesAndLadders 类也可以通过 扩展 的方式来遵循 TextRepresentable 协议：
    extension SnakesAndLadders: TextRepresentable {
    func asText() -> String {
    return "A game of Snakes and Ladders with \(finalSquare) squares"
    }
    }
    print(game.asText())
    // 输出 "A game of Snakes and Ladders with 25 squares"

## 3.通过扩展补充协议声明 ##

当一个类型已经实现了协议中的所有要求，却没有声明为遵循该协议时，可以通过扩展(空的扩展体)来补充协议声明:

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

从现在起， Hamster 的实例可以作为 TextRepresentable 类型使用

let simonTheHamster = Hamster(name: "Simon")
    let somethingTextRepresentable: TextRepresentable = simonTheHamster
    print(somethingTextRepresentable.asText())
    // 输出 "A hamster named Simon"

注意  
即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出显式的协议声明。

## 4.集合中的协议类型 ##

协议类型可以在集合使用，表示集合中的元素均为协议类型，下面的例子创建了一个类型为 TextRepresentable的数组:

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

如下所示， things 数组可以被直接遍历，并打印每个元素的文本表示:

for thing in things {
    print(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 方法

## 5.协议的继承 ##

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

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 协议定义
    }
    如下所示， PrettyTextRepresentable 协议继承了 TextRepresentable 协议
    protocol PrettyTextRepresentable: TextRepresentable {
    func asPrettyText() -> String
    }

例子中定义了一个新的协议 PrettyTextRepresentable ，它继承自 TextRepresentable 协议。任何遵循 PrettyTextRepresentable 协议的类型在满足该协议的要求时，也必须满足 TextRepresentable 协议的要求。在这个例子中， PrettyTextRepresentable 协议要求其遵循者提供一个返回值为 String 类型的 asPrettyText 方法。

如下所示，扩展 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
    }
    }

上述扩展使得 SnakesAndLadders 遵循了 PrettyTextRepresentable 协议，并为每个 SnakesAndLadders 类型提供了了协议要求的 asPrettyText() 方法。每个 PrettyTextRepresentable 类型同时也是 TextRepresentable 类型，所以在 asPrettyText 的实现中，可以调用 asText() 方法。之后在每一行加上换行符，作为输出的开始。然后遍历数组中的元素，输出一个几何图形来表示遍历的结果:

当从数组中取出的元素的值大于0时，用 ▲ 表示  
当从数组中取出的元素的值小于0时，用 ▼ 表示  
当从数组中取出的元素的值等于0时，用 ○ 表示

任意 SankesAndLadders 的实例都可以使用 asPrettyText() 方法。

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

## 6.类专属协议 ##

你可以在协议的继承列表中,通过添加 class 关键字,限制协议只能适配到类（class）类型。（结构体或枚举不能遵循该协议）。该 class 关键字必须是第一个出现在协议的继承列表中，其后，才是其他继承协议。

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
    // class-only protocol definition goes here
    }

在以上例子中，协议 SomeClassOnlyProtocol 只能被类（class）类型适配。如果尝试让结构体或枚举类型适配该协议，则会出现编译错误。

注意  
当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。

协议合成有时候需要同时遵循多个协议。你可以将多个协议采用 protocol

## 7.检验协议的一致性 ##

你可以使用 is 和 as 操作符来检查是否遵循某一协议或强制转化为某一类型。

*  is 操作符用来检查实例是否 遵循 了某个 协议
 *  as? 返回一个可选值，当实例 遵循 协议时，返回该协议类型;否则返回 nil
 *  as 用以强制向下转型，如果强转失败，会引起运行时错误。

下面的例子定义了一个 HasArea 的协议，要求有一个 Double 类型可读的 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 }
    }

Circle 类把 area 实现为基于 存储型属性 radius的 计算型属性 ， Country 类则把 area 实现为 存储型属性 。这两个类都 遵循 了 HasArea 协议。

如下所示，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 数组使用字面量初始化，数组包含一个 radius 为2的 Circle 的实例，一个保存了英国面积的 Country实例和一个 legs 为4的 Animal 实例。

如下所示， 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? 操作符将其 可选绑定(optional binding) 到 objectWithArea 常量上。 objectWithArea 是 HasArea 协议类型的实例，因此 area 属性是可以被访问和打印的。  
objects 数组中元素的类型并不会因为强转而丢失类型信息，它们仍然是 Circle ， Country ， Animal 类型。然而，当它们被赋值给 objectWithArea 常量时，则只被视为 HasArea 类型，因此只有 area 属性能够被访问。

## 8.对可选协议的规定 ##

协议可以含有可选成员，其 遵循者 可以选择是否实现这些成员。在协议中使用 optional 关键字作为前缀来定义可选成员。  
可选协议在调用时使用 可选链 ，因为协议的遵循者可能没有实现可选内容。像 someOptionalMethod?(someArgument) 这样，你可以在可选方法名称后加上 ? 来检查该方法是否被实现。可选方法和可选属性都会返回一个 可选值(optional value) ，当其不可访问时， ? 之后语句不会执行，并整体返回 nil。

注意  
可选协议只能在含有 @objc 前缀的协议中生效。且 @objc 的协议只能被 类 遵循这个前缀表示协议将暴露给Objective-C代码，详情参见 Using Swift with Cocoa and Objective-C 。即使你不打算和Objective-C有什么交互，如果你想要指明协议包含可选属性，那么还是要加上 @obj 前缀。

下面的例子定义了一个叫 Counter 的整数加法类，它使用外部的数据源来实现每次的增量。数据源是两个可选属性，在 CounterDataSource 协议中定义:

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

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

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

这里使用了两种可选链方法。由于 dataSource 可能为 nil ，因此在 dataSource 后边加上了 ? 标记来表明只在dataSource 非空时才去调用 incrementForCount 方法。即使 dataSource 存在，但是也无法保证其是否实现了 incrementForCount 方法，因此在 incrementForCount 方法后边也加有 ? 标记。

调用 incrementForCount 方法在上述两种情形都有可能失败，所以返回值为 可选 Int 类型。虽然在 CounterDataSource 中， incrementForCount 被定义为一个非可选 Int (non-optional)，但是这里我们仍然需要返回 可选Int 类型。

在调用 incrementForCount 方法后， Int 型 可选值 通过 可选绑定(optional binding) 自动拆包并赋值给常量 amount 。如果可选值确实包含一个数值，这表示 delegate 和方法都存在，之后便将 amount 加到 count 上，增加操作完成。

如果没有从 incrementForCount(\_:) 获取到值，可能是 dataSource 为nil，或者它并没有实现 incrementForCount 方法——那么 increment() 方法将试图从数据源的 fixedIncrement 属性中获取增量。 fixedIncrement 也是一个可选型，所以在属性名的后面添加 ? 来试图取回可选属性的值。和之前一样，返回值为可选型。

ThreeSource 实现了 CounterDataSource 协议，它实现来可选属性 fixedIncrement ，每次返回值 3 :

@objc class ThreeSource: CounterDataSource {
    let fixedIncrement = 3
    }

可以使用 ThreeSource 的实例作为 Counter 实例的数据源:

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

上述代码新建了一个 Counter 实例；将它的数据源设置为 TreeSource 实例；调用 increment() 4次。和你预想的一样，每次在调用的时候， count 的值增加3.

下面是一个更为复杂的数据源 TowardsZeroSource ，它将使得最后的值变为0:

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

TowardsZeroSource 实现了 CounterDataSource 协议中的 incrementForCount(\_:) 方法，以 count 参数为依据，计算出每次的增量。如果 count 已经为0，方法返回0，这表示之后不会再有增量。  
你可以配合使用 TowardsZeroSource 实例和 Counter 实例来从 -4 增加到 0 .一旦增加到 0 ，数值便不会再有变动。  
在下面的例子中，将从 -4 增加到 0 。一旦结果为 0 ，便不在增加:

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

## 9.协议扩展 ##

使用扩展协议的方式可以为遵循者提供方法或属性的实现。通过这种方式，可以让你无需在每个遵循者中都实现一次，无需使用全局函数，你可以通过扩展协议的方式进行定义。

例如，可以扩展 RandomNumberGenerator 协议，让其提供 randomBool() 方法。该方法使用协议中要求的 random() 方法来实现:

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"

### 9.1提供默认实现 ###

可以通过协议扩展的方式来为协议规定的属性和方法提供默认的实现。如果协议的遵循者对规定的属性和方法提供了自己的实现，那么遵循者提供的实现将被使用。

注意  
通过扩展协议提供的协议实现和可选协议规定有区别。虽然协议遵循者无需自己实现，通过扩展提供的默认实现，可以不是用可选链调用。  
例如， PrettyTextRepresentable 协议，继承了TextRepresentable 协议，可以为其提供一个默认的 asPrettyText() 方法来简化返回值  
extension PrettyTextRepresentable \{  
func asPrettyText() -> String \{  
return asText()  
\}  
\}

### 9.2 为协议扩展添加限制条件 ###

在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用 where 关键字来描述限制情况。:

例如，你可以扩展 CollectionType 协议，但是只适用于元素遵循 TextRepresentable 的情况:

extension CollectionType where Generator.Element : TextRepresentable {
    func asList() -> String {
    return "(" + ", ".join(map({$0.asText()})) + ")"
    }
    }

asList() 方法将每个元素以 asText() 的方式表示，最后以逗号分隔链接起来。  
现在我们来看 Hamster ，它遵循 TextRepresentable :

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

因为 Array 遵循 CollectionType 协议，数组的元素又遵循 TextRepresentable 协议，所以数组可以使用 asList() 方法得到数组内容的文本表示:

print(hamsters.asList())
    // 输出 "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"

注意  
如果有多个协议扩展，而一个协议的遵循者又同时满足它们的限制，那么将会使用所满足限制最多的那个扩展。

总结：关于Swift中的协议的用法基本上就这些，谢谢阅读。

[20160603213258019]: /images/20220722/71c1406a1ee54fe3a16f58678bd0e78f.png