協議
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 {
static var someTypeProperty: Int { get set }
}
FullyNamed協議含有fullName屬性。因此其遵循者必須含有一個名爲fullName,類型爲String的可讀屬性
protocol FullyNamed {
var fullName: String { get }
}
Person結構體含有一個名爲fullName的存儲型屬性,完整的遵循了協議。(若協議未被完整遵循,編譯時則會報錯)。
struct Person: FullyNamed{
var fullName: String
}
let john = Person(fullName: "John Appleseed")
//john.fullName 爲 "John Appleseed"
Starship類將fullName實現爲只讀的計算型屬性。它的每一個實例都有一個名爲name的必備屬性和一個名爲prefix的可選屬性。 當prefix存在時,將prefix插入到name之前來爲Starship構建fullName。
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 != nil ? prefix! + " " : "") + name
}
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
// ncc1701.fullName == "USS Enterprise"
方法要求
協議能夠要求其遵循者必備某些特定的實例方法和類方法。協議方法的聲明與普通方法聲明相似,但它不需要方法內容。
注意:協議方法支持變長參數(variadic parameter),不支持默認參數(default parameter)。
RandomNumberGenerator協議要求其遵循者必須擁有一個名爲random,返回值類型爲Double的實例方法。
protocol RandomNumberGenerator {
func random() -> Double
}
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關鍵字來表示該函數允許改變該實例和其屬性的類型
注意:用class實現協議中的mutating方法時,不用寫mutating關鍵字;用結構體,枚舉實現協議中的mutating方法時,必須寫mutating關鍵字。
protocol Togglable {
mutating func toggle()
}
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
// RandomNumberGenerator爲協議
let generator: RandomNumberGenerator
init(sides: Int, generator: RandomNumberGenerator) {
self.sides = sides
self.generator = generator
}
func roll() -> Int {
// generator.random()創建[0-1]區間的隨機數種子
return Int(generator.random() * Double(sides))+1
}
}
//類Dice的構造過程需要一個RandomNumberGenerator協議類型的形參。
var line = LinearCongruentialGenerator()
var d6 = Dice(sides: 6, generator: line)
for _ in 1...5{
println("Randow 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
委託(代理)模式
委託是一種設計模式,它允許類或結構體將一些需要它們負責的功能交由(委託)給其他的類型。
委託模式的實現很簡單: 定義協議來封裝那些需要被委託的函數和方法,使其遵循者擁有這些被委託的函數和方法。
委託模式可以用來響應特定的動作或接收外部數據源提供的數據,而無需要知道外部數據源的類型。
DiceGame協議可以在任意含有骰子的遊戲中實現。
protocol DiceGame {
var dice:Dice { get }
func play()
}
DiceGameDelegate協議可以用來追蹤DiceGame的遊戲過程。
protocol DiceGameDelegate {
func gameDidStart(game: DiceGame)
func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)
func gameDidEnd(game: DiceGame)
}
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
}
<span style="color:#cc33cc;">var delegate: DiceGameDelegate?</span>
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方法中。
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")
}
}
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”
在拓展中添加協議成員
TextRepresentable協議含有一個asText方法,如下所示:
protocol TextRepresentable {
func asText() -> String
}
extension Dice: TextRepresentable {
func asText() -> String {
return "A \(sides)-sided dice"
}
}
通過擴展的Dice類遵循TextRepresentable協議
此時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())
// prints "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 = simonTheHamster
println(somethingTextRepresentable.asText())
// prints "A hamster named Simon"
注意:即時滿足了協議的所有要求,類型也不會自動轉變,因此你必須爲它做出明顯的協議聲明
集合中的協議類型
協議類型可以被集合使用,表示集合中的元素均爲協議類型
let things: [TextRepresentable] = [game,d12,simonTheHamster]
for thing in things {
//thing被當做是TextRepresentable類型而不是Dice,DiceGame,Hamster等類型。因此能且僅能調用asText方法
println(thing.asText())
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon
協議的繼承
協議能夠繼承一到多個其他協議。語法與類的繼承相似,多個協議間用逗號,分隔
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 協議定義
}
PrettyTextRepresentable協議繼承了TextRepresentable協議
protocol PrettyTextRepresentable: TextRepresentable {
func asPrettyText() -> String
}
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
}
}
println(game.asPrettyText())
協議合成
一個協議可由多個協議採用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)
// prints "Happy birthday Malcolm - you're 21!"
檢驗協議的一致性
①is操作符用來檢查實例是否遵循了某個協議。
②as?返回一個可選值,當實例遵循協議時,返回該協議類型;否則返回nil
③as用以強制向下轉換型。
protocol HasArea {
var area: Double { get }
}
//將area寫爲計算型屬性
class Circle: HasArea {
let pi = 3.1415927
var radius: Double
var area: Double { return pi * radius * radius }
init(radius: Double) { self.radius = radius }
}
//將area寫爲存儲型屬性
class Country: HasArea {
var area: Double
init(area: Double) { self.area = area }
}
class Animal {
var legs: Int
init(legs: Int) { self.legs = legs }
}
let objects: [AnyObject] = [
Circle(radius: 2.0),
Country(area: 243_610),
Animal(legs: 4)
]
迭代判斷存放任意類型的數組objects是否實現了某協議
for object in objects {
//通過as?操作符判斷對象是否實現了某協議
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
objects數組中元素的類型並不會因爲向下轉型而改變,當它們被賦值給objectWithArea時只被視爲HasArea類型,因此只有area屬性能夠被訪問。
可選協議要求
可選協議含有可選成員,其遵循者可以選擇是否實現這些成員。在協議中使用optional關鍵字作爲前綴來定義可選成員
可選協議在調用時使用可選鏈
注:可選協議只能在含有@objc前綴的協議中生效。且@objc的協議只能被類遵循
CounterDataSource協議含有incrementForCount的可選方法和fiexdIncrement的可選屬性
@objc protocol CounterDataSource {
optional func incrementForCount(count: Int) -> Int
optional var fixedIncrement: Int { get }
}
類Counter中含有CounterDataSource?類型的可選屬性dataSource
@objc class Counter {
var count = 0
var dataSource: CounterDataSource?
func increment() {
//由於dataSource可能爲nil,因此在dataSource後邊加上了?標記來表明只在dataSource非空時纔去調用incrementForCount`方法。
//即使dataSource存在,但是也無法保證其是否實現了incrementForCount方法,因此在incrementForCount方法後邊也加有?標記。
if let amount = dataSource?.incrementForCount?(count) {
count += amount
} else if let amount = dataSource?.fixedIncrement {
count += amount
}
}
}
@objc class ThreeSource: CounterDataSource {
let fixedIncrement = 3
//由於協議CounterDataSource中的方法是可選的,所以協議中的方法可以不用實現
}
var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
counter.increment()
println(counter.count)
}
// 3
// 6
// 9
// 12
@objc 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