Day16 协议

1、协议语法

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

     protocol SomeProtocol {
     // 这里是协议的定义部分
     }
    
    //要让自定义类型遵循某个协议

    struct SomeStructure: FirstProtocol, AnotherProtocol {
        // 这里是结构体的定义部分
    }
    
    //拥有父类的类在遵循协议时，应该将父类名放在协议名之前，以逗号分隔:
    class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
        // 这里是类的定义部分
    }

2、属性要求

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

    protocol SomeProtocol {
        var mustBeSettable: Int { get set }
        var doesNotNeedToBeSettable: Int { get }
    }
    
    //在协议中定义类型属性时，总是使用 static 关键字作为前缀
    protocol AnotherProtocol {
        static var someTypeProperty: Int { get set }
    }
    
    //如下所示，这是一个只含有一个实例属性要求的协议 eg:
     protocol FullyNamed {
     var fullName: String { get }
     }
    
    //下面是一个遵循 FullyNamed 协议的简单结构体:
    struct Person: FullyNamed {
        var fullName: String
    }
    let john = Person(fullName: "John Appleseed")
    print("john.fullName is \(john.fullName)")
    // john.fullName 为 "John Appleseed"

    
    //下面是一个更为复杂的类，它适配并遵循了 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
        }
    }
    let ncc1701 = Starship(name: "Enterprise", prefix: "USS")
    print("ncc1701.fullName is \(ncc1701.fullName)")
    // ncc1701.fullName 是 "USS Enterprise"

3、方法要求

    //协议可以要求遵循协议的类型实现某些指定的实例方法或类方法

    protocol SomeProtocol {
        static func someTypeMethod()
    }

    
    //下面的例子定义了一个只含有一个实例方法的协议:
     protocol RandomNumberGenerator {
        func random() -> Double
     }

    //如下所示，下边是一个遵循并符合 RandomNumberGenerator 协议的类:
    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).truncatingRemainder(dividingBy: 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”

4、Mutating 方法要求

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

    protocol Togglable {
        mutating func toggle()
    }

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

    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()
    print("lightSwitch value is \(lightSwitch)")
    // lightSwitch 现在的值为 .On

5、构造器要求

    protocol SomeProtocol {
        init(someParameter: Int)
    }
    
    //构造器要求在类中的实现
     //无论哪种情况，你都必须 为构造器实现标上 required 修饰符
    class SomeClass: SomeProtocol {
        required init(someParameter: Int) {
            // 这里是构造器的实现部分
        }
    }

注意
如果类已经被标记为 final ，那么不需要在协议构造器的实现中使用 required 修饰符，因为 final 类不能有子类。

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

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

6、协议作为类型

协议可以像其他普通类型一样使用，使用场景如下:
• 作为函数、方法或构造器中的参数类型或返回值类型
• 作为常量、变量或属性的类型
• 作为数组、字典或其他容器中的元素类型

    //下面是将协议作为类型使用的例子:
    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
        }
    }
    
    //下面的例子展示了如何使用 LinearCongruentialGenerator 的实例作为随机数生成器来创建一个六面骰子:
    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

7、委托(代理)模式

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

    //下面的例子定义了两个基于骰子游戏的协议:
    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 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
        }
    }

8、协议的继承

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

    protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
        // 这里是协议的定义部分
    }
    //如下所示，PrettyTextRepresentable 协议继承了 TextRepresentable 协议:
    protocol PrettyTextRepresentable: TextRepresentable {
        var prettyTextualDescription: String { get }
    }

9、检查协议一致性

你可以使用类型转换中描述的 is 和 as 操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型
• is 用来检查实例是否符合某个协议，若符合则返回 true ，否则返回 false 。
• as? 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 nil 。
• as! 将实例强制向下转换到某个协议类型，如果强转失败，会引发运行时错误。

    //下面的例子定义了一个 HasArea 协议，该协议定义了一个 Double 类型的可读属性 area :
    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 }
     }
     //如下所示，Animal 是一个未遵循 HasArea 协议的类:
     class Animal {
     var legs: Int
     init(legs: Int) { self.legs = legs }
     }
     
     //Circle，Country，Animal 并没有一个共同的基类，尽管如此，它们都是类，它们的实例都可以作为 ect 类型的值，存储在同一个数组中:
     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

10、协议扩展

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

    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 CollectionType where Generator.Element: TextRepresentable {
        var textualDescription: String {
            let itemsAsText = self.map { $0.textualDescription }
            return "[" + itemsAsText.joinWithSeparator(", ") + "]"
        }
    }
    textualDescription 属性返回整个集合的文本描述，它将集合中的每个元素的文本描述以逗号分隔的方式连接起
     来，包在一对方括号中。