swift 协议

最新推荐文章于 2024-06-04 16:14:17 发布

ChasingDreamsCoder

最新推荐文章于 2024-06-04 16:14:17 发布

阅读量522

点赞数

分类专栏： swift 文章标签： swift 协议

本文链接：https://blog.csdn.net/ChasingDreamsCoder/article/details/69386395

版权

swift 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

协议定义了一个蓝图，规定了用来实现某一特定任务或者功能的方法、属性，以及其他需要的东西。类、结构体或枚举都可以遵循协议，并未协议定义的这些要求提供具体实现。某个类型能都满足某个协议的要求，就可以说该类型遵循这个协议。

除了遵循协议的类型必须实现在要求外，还可以对协议进行扩展，通过扩展来实现一部分要求或者实现一些附加功能，这样遵循协议的类型就能够使用这些功能。

属性要求

协议可以要求遵循协议的类型提供特定名称和类型的实例属性或类型属性。协议不指定属性是存储类型属性还是计算型属性，它只指定属性的名称和类型。此外，协议还指定属性是可读的还是可读写的。

如果协议要求属性是可读可写的，那么该属性不能是常量属性或只读的计算型属性。如果协议只要求属性是可读的，如果代码需要的话，还可以是可写的。

协议总是用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 }
}

FullyNamed协议除了要求遵循协议的类型提供fullName属性外，并没有其他特别的要求。这个协议表示，任何遵循FullyNamed的类型，都必须有一个可读的String类型的实例属性fullName。

下面是一个遵循FullyNamed协议的简单结构体：

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

这个例子中定义了一个叫Person的结构体，用来表示一个具有名字的人。从第一行代码可以看出，它遵循了FullyNamed协议。

Person结构体的每一个实例都有一个String类型的存储型属性fullName。这正好满足了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 != nil ? prefix! + " " : "") + name
} }
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")

方法要求

协议可以要求遵循协议的类型实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是，不支持为协议中的方法的参数提供默认值。

正如属性要求中所述，在协议中定义类方法的时候，总是使用static关键字作为前缀。当类类型遵循协议时，除了static关键字，还可以使用class关键字作为前缀：

protocol SomeProtocol {
    static func someTypeMethod()
}

下面的例子定义了一个只含有一个实例方法的协议：

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”

Mutating 方法要求

有时需要在方法中改变方法所属的实例。例如，在值类型的实例方法中，mutating关键字作为方法的前缀，写在func关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。

如果你在协议中定义了一个实例方法，该方法会改变遵循该协议的类型的实例，那么在定义协议时需要在方法前加mutating关键字。这使得结构体和枚举能够遵循此协议并满足此方法要求。

protocol Togglable {
    mutating func toggle()
}

当使用枚举或结构体来实现Togglable协议时，需要提供一个带有mutating前缀的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()

构造器要求

协议可以要求遵循协议的类型实现指定的构造器。可以像编写普通构造器那样，在协议的定义里写下构造器的声明，但不需要写花括号和构造器实体：

protocol SomeProtocol {
    init(someParameter: Int)
}

构造器要求在类中的实现

可以在遵循协议的类中实现构造器，无论是作为指定构造器，还是作为便利构造器，无论哪种情况，都必须为构造器实现标上required修饰符：

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
// 这里是构造器的实现部分 }
}

使用required修饰符可以确保所有子类也必须提供此构造器实现，从而也能符合协议。

protocol SomeProtocol {
    init()
}
class SomeSuperClass {
    init() {
// 这里是构造器的实现部分 }
}
class SomeSubClass: SomeSuperClass, SomeProtocol { // 因为遵循协议，需要加上 required
// 因为继承自父类，需要加上 override
required override init() {
// 这里是构造器的实现部分 }
}

可失败构造器要求

遵循协议的类型可以通过失败构造器或非可失败构造器来满足协议中定义的可失败构造器要求。协议中定义的非可失败构造器要求可以通过非可失败构造器或隐式解包可失败构造器来满足。

协议作为类型

尽管协议本身并未实现任何功能，但是协议可以被当做一个成熟的类型来用。

协议可以像其他普通类型一样使用，使用场景如下：

作为函数、方法或构造器中的参数类型或返回值类型

作为常量、变量或属性的类型

作为数组、字典或其他容器中的元素类型

下面是将协议作为类型使用的例子：

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

generator属性的类型为RandomNumberGenerator，因此任何遵循了RandomNumberGenerator协议的类型的实例都可以赋值给generator，除此之外并无其他要求。

 var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
 for _ in 1...5 {
     print("Random dice roll is \(d6.roll())")
 }

委托模式

委托是一种设计模式，它允许类或结构体将一些需要他们负责的功能委托给其他类型的实例。委托模式的实现很简单：定义协议来封装那些需要被委托的功能，这样就能保证遵循协议的类型能提供这些功能。委托模式可以用来响应特定的动作，或者接受外部数据源提供的数据，而无需关心外部数据源的类型。

下面的例子定义了两个基于骰子游戏的协议:

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

如下所示：

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

该类遵循了DiceGame协议，并且提供了相应的可读的dice属性和play()方法。

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

delegate不是游戏的必备条件，因此delegate被定义为DiceGameDelegate类型的可选属性。因为delegate是可选值，因此会自动赋予初始值nil。随后，可以在游戏中为delegate设置适当的值。

DiceGameDelegate协议提供了三个方法用来追踪游戏过程。这三个方法被放置于游戏的逻辑中，即play()方法内。分别在游戏开始时，新一轮开始时，以及游戏结束时被调用。因为delegate是一个DiceGameDelegate类型的可选属性，因此在play()方法中通过可选链式调用它的方法。若delegate属性为nil，则调用方法会优雅的失败，并不会产生错误。若delegate并为nil，则方法能够被调用，并传递SnakesAndLadders实例作为参数。

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

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

gameDidStart(_:)方法从game参数获取游戏信息并打印。game参数是DiceGame类型而不是SnakeAndLadders类型，所以在gameDidStart(_:)方法中只能访问DiceGame协议中的内容。当然了，SnakeAndLaddders的方法也可以在类型转换之后调用。

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

通过扩展添加协议一致性

即便无法修改源代码，依然可以通过扩展令已有类型遵循并符合协议。扩展可以为已有类型添加属性、方法、下标以及构造器，因此可以符合协议中的相应要求。

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)

extension SnakesAndLadders: TextRepresentable {
    var textualDescription: String {
        return "A game of Snakes and Ladders with \(finalSquare) squares"
    }
}
print(game.textualDescription)

通过扩展遵循协议

当一个类型已经符合了某个协议中的所有要求，却还没有声明遵循该协议时，可以通过空扩展体的扩展来遵循该协议：

struct Hamster {
    var name: String
       var textualDescription: String {
        return "A hamster named \(name)"
} }
extension Hamster: TextRepresentable {}

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

let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster

协议的继承

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

protocol PrettyTextRepresentable: TextRepresentable {
    var prettyTextualDescription: String { get }
}

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

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

类类型专属协议

可以在协议的继承列表中，通过添加class关键字来限制协议只能被类类型遵循，而结构体或枚举不能遵循该协议。class关键字必须第一个出现在协议的继承列表中，在其他继承的协议之前：

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol { // 这里是类类型专属协议的定义部分
}

协议合成

有时候需要同时遵循多个协议，可以将多个协议采用&进行组合

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21) wishHappyBirthday(to: birthdayPerson)

Named协议包含String类型的name属性。Aged协议包含Int类型的age属性。Person结构体遵循了这两个协议。

wishHappyBirthday(to:)函数的参数celebrator的类型为Named&Aged。这意味着它不关心参数的具体类型，只要参数符合这两个协议即可。

检查协议一致性

可以使用类型转换中的描述的is和as操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型。检查和转换到某个协议类型在语法上和类型的检查和转换完全相同：

is用来检查实例是否符合某个协议，若符合则返回true，否则返回false。

as？返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回nil。

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

Circle类把area属性实现为基于存储型属性radius的计算型属性。country类则把area属性实现为存储型属性。这两个类都正确的符合了HasArea协议。

如下：

class Animal {
    var legs: Int
    init(legs: Int) { self.legs = legs }
}

上面的三个类并没有一个共同的基类，尽管如此，他们都是类，他们的实例都可以作为AnyObject类型的值，存储在同一个数组中：

let objects: [AnyObject] = [
    Circle(radius: 2.0),
    Country(area: 243_610),
    Animal(legs: 4)
]

如下所示，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?操作符返回的可选值通过可选绑定，绑定到objectWithArea常量上。objectWithArea是HasArea协议类型的实例，因此area属性可以被访问和打印。

可选的协议要求

协议可以定义可选要求，遵循协议的类型可以选择是否实现这些要求。在协议中使用optional关键字作为前缀来定义可选要求。可选要求用在你需要和oc打交道的代码中，协议和可选要求都必须带上@objc属性。标记@objc特性的协议只能被继承自oc类的类或者@objc类遵循，其他类以及结构体和枚举均不能遵循这种协议。

使用可选要求时，他们的类型会自动变成可选的。比如，一个类型为(Int) ->String 的方法会变成((Int)->String)?。需要注意的是整个函数类型是可选的，而不是函数的返回值。

协议中的可选要求可通过可选链式调用来使用，因为遵循协议的类型可能没有实现这些可选要求。类似someOptonalMethod?(someArgument)这样，可以在可选方法名称后加上？来调用可选方法。

下面的例子定义了一个名为Counter的用于整数技术的类：

@objc protocol CounterDataSource {
    optional func incrementForCount(count: Int) -> Int
    optional var fixedIncrement: Int { get }
}

这个协议定义了一个可选方法和一个可选属性，他们使用了不同的方法来从数据源中获取适当的增量值。

Counter类含有CounterDataSource？类型的可选属性：

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

下面的例子展示了CounterDataSource的简单实现。ThreeSource类遵循了CounterDataSource协议，它实现了可选属性fixedIncrement，每次回返回3：

 class ThreeSource: NSObject, CounterDataSource {
     let fixedIncrement = 3
}

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

 var counter = Counter()
 counter.dataSource = ThreeSource()
 for _ in 1...4 {
     counter.increment()
     print(counter.count)
 }

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

 @objc class TowardsZeroSource: NSObject, CounterDataSource {
     func increment(forCount 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)
 }

协议扩展

协议可以通过扩展来为遵循协议的类型提供属性、方法以及下标的实现。通过这种方式，可以基于协议本身来实现这些功能，而无需在每个遵循协议的类型中都重复同样的实现，也无需使用全局函数。

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”

提供默认实现

可以通过协议扩展来为协议要求的属性、方法以及下标提供默认的实现。如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中默认实现被使用。

extension PrettyTextRepresentable  {
    var prettyTextualDescription: String {
        return textualDescription
    }
}

为协议扩展添加限制条件

在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用where子句来描述。

 extension CollectionType where Generator.Element: TextRepresentable {
     var textualDescription: String {
         let itemsAsText = self.map { $0.textualDescription }
         return "[" + itemsAsText.joinWithSeparator(", ") + "]"
     }
}

现在来看看先前的Hamster结构体，它符合TextRepresentable协议，同时这里还有个装有Hamster的实例的数组：

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

选择《the swift programming language》中文版