协议定义了一个蓝图,规定了用来实现某一特定任务或者功能的方法、属性,以及其他需要的东西。
类、结构体或枚举都可以采纳协议,并为协议定义的这些要求提供具体实现。某个类型能够满足某个协议的要求,就可以说该类型“符合”这个协议。
除了采纳协议的类型必须实现的要求外,还可以对协议进行扩展,通过扩展来实现一部分要求或者实现一些附加功能,这样采纳协议的类型就能够使用这些功能。
协议语法(Protocol Syntax)
- 协议的定义用protocol关键字
protocol SomeProtocol {
// 这里是协议的定义部分
}
- 要让自定义类型遵循某个协议,在定义类型时,需要在类型名称后加上协议名称,中间以冒号(:)分隔。遵循多个协议时,各协议之间用逗号(,)分隔。
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 这里是结构体的定义部分
}
- 拥有父类的类在遵循协议时,应该将父类名放在协议名之前,以逗号分隔。
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 这里是类的定义部分
}
属性要求(Property Requirements)
协议可以要求遵循协议的类型提供特定名称和类型的实例属性或类型属性。
协议不指定属性是存储型属性还是计算型属性,它只指定属性的名称和类型。
协议还指定属性是可读的还是可读可写的。
如果协议要求属性是可读可写的,那么该属性不能是常量属性或只读的计算型属性。如果协议只要求属性是可读的,那么该属性不仅可以是可读的,如果代码需要的话,还可以是可写的。
协议要求的是基本条件,实现时可以多,但是不能少
- 协议总是用 var关键字来声明变量属性,在类型声明后加上 { set get }来表示属性是可读可写的,可读属性则用 { get }来表示:
protocol SomeProtocol {
var mustBeSettable: Int { get set }
var doesNotNeedToBeSettable: Int { get }
}
- 在协议中定义类型属性时,总是使用 static关键字作为前缀。当类类型遵循协议时,除了 static 关键字,还可以使用 class关键字来声明类型属性:
protocol AnotherProtocol {
static var someTypeProperty: Int { get set }
}
一个例子:
protocol FullyNamed {
var fullName: String { get }
}
struct Person: FullyNamed {
var fullName: String
}
let john = Person(fullName: "John Appleseed")
// john.fullName 为 "John Appleseed"
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"
方法要求(Method Requirements)
协议可以要求遵循协议的类型实现某些指定的实例方法或类方法。这些方法作为协议的一部分,像普通方法一样放在协议的定义中,但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法,和普通方法的定义方式相同。但是,不支持为协议中的方法的参数提供默认值。
在协议中定义类方法的时候,总是使用 static关键字作为前缀。当类类型采纳协议时,除了static关键字,还可以使用 class关键字作为前缀
Mutating 方法要求(Mutating Method Requirements)
如果在协议中定义了一个实例方法,该方法会改变遵循该协议的类型的实例,那么在定义协议时需要在方法前加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
构造器要求(Initializer Requirements)
- 协议可以要求遵循协议的类型实现指定的构造器。可以像编写普通构造器那样,在协议的定义里写下构造器的声明,但不需要写花括号和构造器的实体。
protocol SomeProtocol {
init(someParameter: Int)
}
构造器要求在类中的实现(Class Implementations of Protocol Initializer Requirements)
可以在遵循协议的类中实现构造器,无论是作为指定构造器,还是作为便利构造器。无论哪种情况,都必须为构造器实现标上 required修饰符。
使用 required修饰符可以确保所有子类也必须提供此构造器实现,从而也能符合协议。
如果类已经被标记为 final,那么不需要在协议构造器的实现中使用 required修饰符,因为 final类不能有子类。
如果一个子类重写了父类的指定构造器,并且该构造器满足了某个协议的要求,那么该构造器的实现需要同时标注required和 override修饰符。
protocol SomeProtocol {
init()
}
class SomeSuperClass {
init() {
// 这里是构造器的实现部分
}
}
class SomeSubClass: SomeSuperClass, SomeProtocol {
// 因为采纳协议,需要加上 required
// 因为继承自父类,需要加上 override
required override init() {
// 这里是构造器的实现部分
}
}
失败构造器要求(Failable Initializer Requirements)
协议还可以为遵循协议的类型定义可失败构造器要求。
遵循协议的类型可以通过可失败构造器(init?)或非可失败构造器(init)来满足协议中定义的可失败构造器要求。
协议中定义的非可失败构造器要求可以通过非可失败构造器(init)或隐式解包可失败构造器(init!)来满足
协议作为类型(Protocols as Types)
尽管协议本身并未实现任何功能,但是协议可以被当做一个成熟的类型来使用。
协议是一种类型,因此协议类型的名称应使用大写字母开头的驼峰式写法。
委托(代理)模式(Delegation)
委托是一种设计模式,它允许类或结构体将一些需要它们负责的功能委托给其他类型的实例来实现。
委托模式的实现很简单:定义协议来封装那些需要被委托的功能,这样就能确保遵循协议的类型能提供这些功能。
委托模式可以用来响应特定的动作,或者接收外部数据源提供的数据,而无需关心外部数据源的类型。
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()
print("Here's a random number: \(generator.random())")
// 打印 “Here's a random number: 0.37464991998171”
print("And another one: \(generator.random())")
// 打印 “And another one: 0.729023776863283”
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
}
}
var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
print("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)
}
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)
}
}
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 += 1
print("Rolled a \(diceRoll)")
}
func gameDidEnd(game: DiceGame) {
print("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
通过扩展添加协议一致性(Adding Protocol Conformance with an Extension)
即便无法修改源代码,依然可以通过扩展令已有类型采纳并符合协议。
扩展可以为已有类型添加属性、方法、下标以及构造器,因此可以符合协议中的相应要求。
通过扩展令已有类型遵循并符合协议时,该类型的所有实例也会随之获得协议中定义的各项功能。
protocol TextRepresentable {
var textualDescription: String { get }
}
extension Dice: TextRepresentable {
var textualDescription: String {
return "A \(sides)-sided dice"
}
}
let d12 = Dice(sides: 12, generator: LinearCongruentialGenerator())
print(d12.textualDescription)
// 打印 “A 12-sided dice”
extension SnakesAndLadders: TextRepresentable {
var textualDescription: String {
return "A game of Snakes and Ladders with \(finalSquare) squares"
}
}
print(game.textualDescription)
// 打印 “A game of Snakes and Ladders with 25 squares”
通过扩展遵循协议(Declaring Protocol Adoption with an Extension)
当一个类型已经符合了某个协议中的所有要求,却还没有声明采纳该协议时,可以通过空扩展体的扩展来采纳该协议
即使满足了协议的所有要求,类型也不会自动遵循协议,必须显式地遵循协议。
struct Hamster {
var name: String
var textualDescription: String {
return "A hamster named \(name)"
}
}
extension Hamster: TextRepresentable {}
let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
print(somethingTextRepresentable.textualDescription)
// 打印 “A hamster named Simon”
协议类型的集合(Collections of Protocol Types)
- 协议类型可以在数组或者字典这样的集合中使用。
let things: [TextRepresentable] = [game, d12, simonTheHamster]
for thing in things {
print(thing.textualDescription)
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon
协议的继承(Protocol Inheritance)
- 协议能够继承一个或多个其他协议,可以在继承的协议的基础上增加新的要求。
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 这里是协议的定义部分
}
protocol PrettyTextRepresentable: TextRepresentable {
var prettyTextualDescription: String { get }
}
extension SnakesAndLadders: PrettyTextRepresentable {
var prettyTextualDescription: String {
var output = textualDescription + ":\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
}
}
print(game.prettyTextualDescription)
// A game of Snakes and Ladders with 25 squares:
// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
类类型专属协议(Class-Only Protocols)
可以在协议的继承列表中,通过添加 class关键字来限制协议只能被类类型采纳,而结构体或枚举不能采纳该协议。
class关键字必须第一个出现在协议的继承列表中,在其他继承的协议之前。
当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时,应该采用类类型专属协议。
protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
// 这里是类类型专属协议的定义部分
}
协议合成(Protocol Composition)
可以将多个协议采用 protocol<SomeProtocol, AnotherProtocol>这样的格式进行组合,称为 协议合成(protocol composition)。
可以在 <>中罗列任意多个你想要采纳的协议,以逗号分隔。
协议合成并不会生成新的、永久的协议类型,而是将多个协议中的要求合成到一个只在局部作用域有效的临时协议中。
protocol Named {
var name: String { get }
}
protocol Aged {
var age: Int { get }
}
struct Person1: Named, Aged { // 为了防止和前面的Person重名
var name: String
var age: Int
}
func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
print("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
}
let birthdayPerson = Person1(name: "Malcolm", age: 21)
wishHappyBirthday(birthdayPerson)
// 打印 “Happy birthday Malcolm - you're 21!”
检查协议一致性(Checking for Protocol Conformance)
可以使用 is和 as操作符来检查协议一致性,即是否符合某协议,并且可以转换到指定的协议类型。
is用来检查实例是否符合某个协议,若符合则返回 true,否则返回 false。
as?返回一个可选值,当实例符合某个协议时,返回类型为协议类型的可选值,否则返回 nil。
as! 将实例强制向下转换到某个协议类型,如果强转失败,会引发运行时错误。
!不建议用,优先考虑as?
protocol HasArea {
var area: Double { get }
}
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 }
}
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)
]
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
可选的协议要求(Optional Protocol Requirements)
协议可以定义可选要求,遵循协议的类型可以选择是否实现这些要求。
在协议中使用 optional关键字作为前缀来定义可选要求。
使用可选要求时(例如,可选的方法或者属性),它们的类型会自动变成可选的。比如,一个类型为 (Int) -> String的方法会变成 ((Int) -> String)?。需要注意的是整个函数类型是可选的,而不是函数的返回值。
协议中的可选要求可通过可选链式调用来使用,因为遵循协议的类型可能没有实现这些可选要求。类似someOptionalMethod(someArgument)这样,可以在可选方法名称后加上 ?来调用可选方法。
可选的协议要求只能用在标记 @objc特性的协议中。
标记 @objc特性的协议只能被继承自 Objective-C 类的类或者 @objc类遵循,其他类以及结构体和枚举均不能遵循这种协议。
@objc protocol CounterDataSource {
optional func incrementForCount(count: Int) -> Int
optional var fixedIncrement: Int { get }
}
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
}
}
}
class ThreeSource: NSObject, CounterDataSource {
let fixedIncrement = 3
}
var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
counter.increment()
print(counter.count)
}
// 3
// 6
// 9
// 12
@objc class TowardsZeroSource: NSObject, 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()
print(counter.count)
}
// -3
// -2
// -1
// 0
// 0
协议扩展(Protocol Extensions)
协议可以通过扩展来为遵循协议的类型提供属性、方法以及下标的实现。通过这种方式,可以基于协议本身来实现这些功能,而无需在每个遵循协议的类型中都重复同样的实现,也无需使用全局函数。
可以通过协议扩展来为协议要求的属性、方法以及下标提供默认的实现。
如果遵循协议的类型为这些要求提供了自己的实现,那么这些自定义实现将会替代扩展中的默认实现被使用。
通过扩展提供的默认实现可以直接调用,而无需使用可选链式调用。
extension RandomNumberGenerator {
func randomBool() -> Bool {
return random() > 0.5
}
}
let generatorDefault = LinearCongruentialGenerator()
print("Here's a random number: \(generatorDefault.random())")
// 打印 “Here's a random number: 0.37464991998171”
print("And here's a random Boolean: \(generatorDefault.randomBool())")
// 打印 “And here's a random Boolean: true”
为协议扩展添加限制条件(Adding Constraints to Protocol Extensions)
在扩展协议的时候,可以指定一些限制条件,只有遵循协议的类型满足这些限制条件时,才能获得协议扩展提供的默认实现。
这些限制条件写在协议名之后,使用 where子句来描述。
如果多个协议扩展都为同一个协议要求提供了默认实现,而遵循协议的类型又同时满足这些协议扩展的限制条件,那么将会使用限制条件最多的那个协议扩展提供的默认实现。
extension CollectionType where Generator.Element: TextRepresentable {
var textualDescription: String {
let itemsAsText = self.map { $0.textualDescription }
return "[" + itemsAsText.joinWithSeparator(", ") + "]"
}
}
let murrayTheHamster = Hamster(name: "Murray")
let morganTheHamster = Hamster(name: "Morgan")
let mauriceTheHamster = Hamster(name: "Maurice")
let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
print(hamsters.textualDescription)
// 打印 “[A hamster named Murray, A hamster named Morgan, A hamster named Maurice]”
- Swift中的protocol带来了面向接口编程的方式;而Object-C中的protocol基本上用于代理模式。这两者是本质概念的不同。
- 面向接口编程提供了一个让不同类型的个体(不单单是类,还有结构体和枚举,所以这里没有用“对象”这个词)协同工作的方式;这个跟Object-C的面向对象,主要通过继承和组合的方式还是有差别的。推荐用面向接口编程的思维方式,耦合性更小,扩展更灵活。
- 协议的扩展提供协议的默认实现,这个功能强烈推荐。在架构设计的时候,就可以提供一个最小实现系统,可以让框架落地。
- 可选要求,optional关键字,目前只限于兼容Object-C。在实际使用中,大部分可选要求都可以用协议扩展提供默认实现来替代,但是“可能没有”这个概念和默认实现还是有差别的。不知道以后是否会加强。
- @objc,class这几个关键字都是为了兼容Object-C,如果不是必要,尽量不要用。
- 协议的继承不可以避免,这个功能是好的,比如继承系统已经定义好的协议,做一些自定义。同样,继承这种方式可读性并不好,基本上不建议多级继承。
- 尽量考虑用组合代替继承,比如protocol<>这种方式可以多用用
- protocol作为类型这个特性也可以多用,让不同的类型用于相同的集合或者函数参数中,实现一定程度上的“动态特性”
- 在框架设计时,多用protocol,少用基类。并且在定义protocol的时候,在同一个文件中,通过扩展,提供protocol的默认实现。