swift 学习- 24 -- 协议 01

// 协议 定义了一个蓝图, 规定了用来实现某一特定任务或者功能的方法, 属性, 以及其他需要的东西.

// 类, 结构体, 或 枚举都可以遵循协议, 并且为协议定义的这些要求 提供具体的实现, 某个类型能够满足某个协议的要求, 就可以说该类型 遵循了这个协议

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

// 协议的语法

// 协议的定义方式 与 类, 结构体 和 枚举的定义非常相似

// protocol SomeProtocol{

//     // 这里是协议的定义部分

// }

//要让自定义类型遵循某个协议, 在定义类型时, 需要在类型名称后面 加上协议名称, 中间已 (:) 分割,遵循多个协议时, 各协议之间以 (,) 分割

// struct SomeStruct: FirstProtocol,AnotherProtocol{

//     // 这里是结构体的定义部分

// }

// 拥有父类的类在组训协议时, 应该将父类的类名放在协议名前面, 以 (,) 分割

// class SomeClass: SomeSuperClass.FirstProtocol,AnotherProtocol{

//     // 这里是类的定义部分

// }

// 属性要求

// 协议 可以要求遵循协议的类型 提供特定名称 和 类型的 实例属性 或类型属性

// 协议 不指定属性是存储型属性 还是 计算型属性, 它只指定属性的名称 和 类型, 此外,协议号指定属性是 可读还是 可读可写的

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

// 协议总是 用 var 关键字来声明变量属性, 在类型名称后面 加上 { set get} 来表示属性是可读可写的, 可读属性则用 {get} 来声明

protocol SomeProtocol{

var mustBeSettable: Int {get set}

var doseNotNeedToBeSettable: Int {get}

}

// 在协议中定义类型属性时, 总是使用 static 关键字作为前缀, 当类类型遵循协议时, 除了 static 关键字,还可以使用 class 关键字来声明类型属性:

protocol AnotherProtocol{

static var someTypeProperty: Int {get set}

}

// 如下所示: 这是一个只含有一个实例属性要求的协议:

protocol FullNamed{

var fullName: String {get}

}

// FullNamed 协议除了要求遵循协议的类型 提供的 fullName 属性外, 并没有其他要求, 这个协议表示, 任何遵循 FullNamed 的类型, 都必须有一个刻度的 String 类型的实例属性 fullName

// 下面是一个遵循 FullNamed 协议的简单结构体

struct Person: FullNamed{

var fullName: String

}

let john = Person.init(fullName: "John Appleseed")

// 这个例子定义了一个 Person 的结构体, 用来表示一个具有名字的人, 它遵循了 FullNamed 协议

// Person 结构体的每一个实例都有一个 String 类型的存储型属性, fullName, 这正好满足了 FullNamed 协议的要求, 就以为着 Person 结构体 正确地符合了协议 (如果协议要求未被完全满足, 在编译时会报错)

// 下面是一个更复杂的例子

class Starship: FullNamed{

var prefix: String?

var name: String

init(name: String,prefix: String?) {

self.name = name

self.prefix = prefix

}

var fullName: String{

return (prefix != nil ? prefix! + " ":"") + name

}

}

var ncc1701 = Starship.init(name: "Enterprise", prefix: "USS")

// 方法要求

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

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

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

protocol RandomNumberGenerator{

func random() -> Double

}

// RandomNumberGenerator 协议要求遵循协议的类型必须拥有一个名为 random ,返回值类型为 Double 的实例方法.尽管这里并未指明,但是我们假设返回值在 [0.0,1.0] 区间内

// RandomNumberGenerator 协议并不关心每一个随机数是怎么生成的,它只要求必须提供一个随机数生活器

// 如下所示:

class LinearCongrentialGenerator: RandomNumberGenerator{

var lastRandom = 42.0

let m = 139968.0

let a = 3877.0

let c = 29573.0

func random() -> Double {

lastRandom = ((lastRandom * a + c).truncatingRemainder(dividingBy: m))

return lastRandom / m

}

}

let  generator = LinearCongrentialGenerator.init()

print("Here's a random number : \(generator.random())")

print("And another one: \(generator.random())")

// Mutating 方法要求

// 有时需要在方法中改变方法所属的实例, 例如, 在值类型(即结构体和枚举)的实例方法中, 将 ,mutating 关键字作为方法的前缀, 写在 func 前面, 表示可以在该方法中修改它所属的实例以及实例的任意属性的值,

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

// 注意 : 实现协议中的 mutating 方法时, 若是类类型, 则不用写 mutating 关键字, 而对于结构体和枚举, 则必须写 mutataing 关键字

protocol Togglable{

mutating func toggle()

}

// toggle() 方法在定义的时候,使用 mutating 关键字标记,这表明当它被调用的时候, 该方法将会改变遵循协议的 类型的实例

// 当使用 枚举 或结构体 来实现 Togglable 协议的时候,需要提供一个带有 mutating 前缀的 toggle() 方法

enum OneOffSwitch: Togglable{

case off, on

mutating func toggle() {

switch self {

case .off:

self = .on

case .on:

self = .off

}

}

}

var lightSwitch = OneOffSwitch.off

lightSwitch.toggle()

// 构造器要求

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

protocol SomeProtocol2{

init(someParameter: Int)

}

// 构造器要求在类中的实现

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

class SomeClass: SomeProtocol2{

required init(someParameter: Int) {

// 这里是构造器的实现部分

}

}

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

// 如果类已经被标记为 final ,那么不需要再协议的构造器的实现值使用 required 修饰符,因为 final 类 不能有子类

// 如果一个子类重写了父类的指定构造器, 并且该构造器满足了某个协议的要求, 那么该构造器的实现需要同时标注 required 和 override 修饰符

protocol SomeProtocol3 {

init()

}

class SomeSuperClass3 {

init() {

// 这里是构造器的实现部分

}

}

class SomeSubClass: SomeSuperClass3, SomeProtocol3 {

// 因为遵循协议，需要加上 required

// 因为继承自父类，需要加上 override

required override init() {

// 这里是构造器的实现部分

}

}

// 可失败构造器要求

// 协议还可以为遵循协议的类型定义可失败的构造器要求

// 遵循协议的类型可以通过课时表的构造器 (init?) 或 非可失败的构造器 (init) 来满足协议中定义的可失败的构造器的要求

// 协议中定义的非可失败构造器要求可以通过非可失败构造器 (init) 或隐式解包可失败构造器 (init!)来满足

// 协议作为类型

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

// 协议可以像其他类型一样使用, 使用场景如下

// 作为函数, 方法 或结构体中的参数类型 或返回值类型

// 作为常量, 变量 或属性的类型

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

// 注意: 协议是一种类型, 因此协议类型的名称应与其他类型 (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

}

}

// 委托 (代理) 模式

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

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 的游戏过程

// 如下所示.

class SankesAndLadders: DiceGame{

let finalSquare = 25

let dice = Dice.init(sides: 6, generator: LinearCongrentialGenerator())

var square = 0

var board: [Int]

init() {

board = [Int].init(repeating: 0, count: finalSquare + 1)

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)

}

}

// 如下实例定义了 DiceGameTracker 类, 它遵循 DiceGameDelegate 协议:

class DIcegameTracker: DiceGameDelegate{

var numberOfTurns = 0

func gameDidStart(_ game: DiceGame) {

numberOfTurns = 0

if game is SankesAndLadders {

print("Started a new game of Snaks 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")

}

}