IOS开发语言Swift入门连载---协议

IOS开发语言Swift入门连载—协议

协议(Protocol)

协议（Protocol）用于定义完成某项任务或功能所必须的方法和属性，协议实际上并不提供这些功能或任务的具体实现(Implementation) –而只用来描述这些实现应该是什么样的。类，结构体，枚举通过提供协议所要求的方法，属性的具体实现来采用(adopt) 协议。任意能够满足协议要求的类型被称为协议的遵循者。
　　协议可以要求其遵循者提供特定的实例属性，实例方法，类方法，操作符或下标脚本等。
　　协议的语法
　　协议 的定义方式与类，结构体，枚举 的定义都非常相似，如下所示

protocol SomeProtocol {    // 协议内容}

　　在类型名称后加上协议名称 ，中间以冒号: 分隔即可实现协议；实现多个协议时，各协议之间用逗号, 分隔，如下所示

struct SomeStructure: FirstProtocol, AnotherProtocol {    // 结构体内容}

　　如果一个类在含有父类 的同时也采用了协议，应当把父类 放在所有的协议 之前，如下所示

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {    // 类的内容}

对属性的规定

　　协议可以规定其遵循者 提供特定名称与类型的实例属性(instance property) 或类属性(type property) ，而不管其是存储型属性(stored property) 还是计算型属性(calculate property) 。此外也可以指定属性是只读的还是可读写的。　　如果协议要求属性是可读写的，那么这个属性不能是常量存储型属性 或只读计算型属性 ；如果协议要求属性是只读的（gettable），那么计算型属性 或存储型属性 都能满足协议对属性的规定，在你的代码中，即使为只读属性实现了写方法（settable）也依然有效。　　协议中的属性经常被加以var 前缀声明其为变量属性，在声明后加上{ set get } 来表示属性是可读写的，只读的属性则写作{ get } ，如下所示：

protocol SomeProtocol {    var mustBeSettable : 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 。任何FullyNamed 类型都得有一个只读的fullName 属性，类型为String 。　　如下所示，这是一个实现了FullyNamed 协议的简单结构体

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

　　这个例子中定义了一个叫做Person 的结构体，用来表示具有指定名字的人。从第一行代码中可以看出，它采用了FullyNamed 协议。　　Person 结构体的每一个实例都有一个叫做fullName ，String类型的存储型属性，这正好匹配了FullyNamed 协议的要求，也就意味着，Person 结构体完整的遵循了协议。（如果协议要求未被完全满足，在编译时会报错　　这有一个更为复杂的类，它采用并实现了FullyNamed 协议，如下所示

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

　　Starship 类把fullName 属性实现为只读的计算型属性 。每一个Starship 类的实例都有一个名为name的必备属性和一个名为prefix 的可选属性。 当prefix 存在时，将prefix 插入到name 之前来为Starship 构建fullName ，prefix 不存在时，则将直接用name构建fullName　　对方法的规定　　协议 可以要求其遵循者 实现某些指定的实例方法 或类方法 。这些方法作为协议的一部分，像普通的方法一样清晰的放在协议的定义中，而不需要大括号和方法体。　　注意： 协议中的方法支持变长参数(variadic parameter) ，不支持参数默认值(default value) 。　　如下所示，协议中类方法的定义与类属性的定义相似，在协议定义的方法前置class 关键字来表示。当在枚举 或结构体 实现类方法时，需要使用static 关键字来代替。

protocol SomeProtocol {    class func someTypeMethod()}

　　如下所示，定义了含有一个实例方法的的协议。

protocol RandomNumberGenerator {    func random() -> Double}

　　RandomNumberGenerator 协议要求其遵循者 必须拥有一个名为random ， 返回值类型为Double e的实例方法。 （尽管这里并未指明，但是我们假设返回值在[0，1]区间内）。　　RandomNumberGenerator 协议并不在意每一个随机数是怎样生成的，它只强调这里有一个随机数生成器。　　如下所示，下边的是一个遵循了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 types) （结构体，枚举）的实例方法中，将mutating 关键字作为函数的前缀，写在func 之前，表示可以在该方法中修改实例及其属性的所属类型。这一过程在Modifyting Value Types from Within Instance Methods章节中有详细描述。　　如果协议中的实例方法打算改变其遵循者 实例的类型，那么在协议定义时需要在方法前加mutating 关键字，才能使结构体，枚举来采用并满足协议中对方法的规定。　　注意： 用类实现协议中的mutating方法时，不用写mutating 关键字；用结构体，枚举 实现协议中的mutating 方法时，必须写mutating 关键字。　　如下所示，Togglable 协议含有名为toggle 的突变实例方法。根据名称推测，toggle 方法应该是用于切换或恢复其遵循者 实例或其属性的类型。

protocol Togglable {    mutating func toggle()}

　　当使用枚举 或结构体 来实现Togglabl 协议时，需要提供一个带有mutating 前缀的toggle 方法。　　如下所示，OnOffSwitch 枚举遵循 了Togglabl 协议，On ，Off 两个成员用于表示当前状态。枚举的toggle 方法被标记为mutating ，用以匹配Togglabl 协议的规定。

enum OnOffSwitch: Togglable {    case Off, On    mutating func toggle() {        switch self {        case Off:            self = On        case On:            self = Off        }    }}var lightSwitch = OnOffSwitch.OfflightSwitch.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 两个属性，前者是整型，用来表示骰子有几个面，后者为骰子提供一个随机数生成器。　　generator 属性的类型为RandomNumberGenerator ，因此任何遵循了RandomNumberGenerator 协议的类型的实例都可以赋值给generator ，除此之外，无其他要求。　　类中也有一个构造器(initializer) ，用来进行初始化操作。构造器中含有一个名为generator ，类型为RandomNumberGenerator 的形参。在调用构造方法时创建Dice 的实例时，可以传入任何遵循RandomNumberGenerator 协议的实例给generator 。　　Dice 类也提供了一个名为roll 的实例方法用来模拟骰子的面值。它先使用generator 的random 方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。generator 被认为是遵循了RandomNumberGenerator 的类型，因而保证了random 方法可以被调用。　　如下所示，这里展示了如何使用LinearCongruentialGenerator 的实例作为随机数生成器创建一个六面骰子

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

委托（代理）模式

　　委托是一种设计模式（译者注： 想起了那年 UITableViewDelegate 中的奔跑，那是我逝去的Objective-C……），它允许类 或结构体 将一些需要它们负责的功能交由(委托) 给其他的类型的实例。　　委托模式的实现很简单： 定义协议 来封装 那些需要被委托的函数和方法 ， 使其遵循者 拥有这些被委托的函数和方法 。　　委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的所属类型（译者注：只要求外部数据源遵循 某协议）。　　下文是两个基于骰子游戏的协议

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 作为初始值。　　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 {            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 类型而不是SnakesAndLadders 类型，所以方法中只能访问DiceGame 协议中的成员。当然了，这些方法也可以在类型转换之后调用。在上例代码中，通过is操作符检查game 是否为 SnakesAndLadders 类型的实例，如果是，则打印出相应的内容。　　无论当前进行的是何种游戏，game 都遵循DiceGame 协议以确保game 含有dice 属性，因此在gameDidStart 方法中可以通过传入的game 参数来访问dice属性，进而打印出dice 的sides 属性的值。　　DiceGameTracker 的运行情况，如下所示

let tracker = DiceGameTracker()let game = SnakesAndLadders()game.delegate = trackergame.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 {    func 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 SnakesAndLadders: 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: TextRepresentable {}

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

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

　　注意： 即时满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明　　集合中的协议类型　　协议类型可以被集合使用，表示集合中的元素均为协议类型

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

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

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

　　注意： @objc 用来表示协议是可选的，也可以用来表示暴露给Objective-C 的代码，此外，@objc 型协议只对类 有效，因此只能在类 中检查协议的一致性。详情查看Using Siwft with Cocoa and Objectivei-c。　　如下所示，定义了Circle 和Country 类，它们都遵循了haxArea 协议

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 实现为存储型属性 。这两个类都遵循 了haxArea 协议。　　如下所示，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。0的Circle 的实例，一个保存了英国面积的Country 实例和一个legs 为4的Animal 实例。　　如下所示，objects 数组可以被迭代，对迭代出的每一个元素进行检查，看它是否遵循了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 常量上。objectWithArea 是HasArea 协议类型的实例，因此area属性是可以被访问和打印的。　　objects 数组中元素的类型并不会因为向下转型 而改变，它们仍然是Circle ，Country ，Animal 类型。然而，当它们被赋值给objectWithArea 常量时，则只被视为HasArea 类型，因此只有area 属性能够被访问。　　对可选协议的规定　　可选协议含有可选成员，其遵循者 可以选择是否实现这些成员。在协议中使用@optional 关键字作为前缀来定义可选成员。　　可选协议在调用时使用可选链 ，详细内容在Optional Chaning章节中查看。　　像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 。　　由于dataSource 可能为nil ，因此在dataSource 后边加上了? 标记来表明只在dataSource 非空时才去调用incrementForCount 方法。　　即使dataSource 存在，但是也无法保证其是否实现了incrementForCount 方法，因此在incrementForCount 方法后边也加有？标记　　在调用incrementForCount 方法后，Int 型可选值 通过可选绑定(optional binding) 自动拆包并赋值给常量amount 。　　当incrementForCount 不能被调用时，尝试使用可选属性fixedIncrement 来代替。　　ThreeSource实现了CounterDataSource 协议，如下所示

class ThreeSource: CounterDataSource {    let fixedIncrement = 3}

　　使用ThreeSource 作为数据源开实例化一个Counter:
[Java] 纯文本查看 复制代码

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

　　下边是执行的代码：

c

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