22.协议

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

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

1.协议语法

//协议语法
protocol SomeProtocol {
    // 这里是协议的定义部分
}

//类型实现协议：类型名称后加上协议名称，中间以冒号（:）分隔。采纳多个协议时，各协议之间用逗号（,）分隔
struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 这里是结构体的定义部分
}

//拥有父类的类型实现协议：将父类名放在协议名之前，以逗号分隔
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 这里是类的定义部分
}

2.属性要求

协议可以要求采纳协议的类型提供特定名称和类型的实例属性或类型属性。协议不指定属性是存储型属性还是计算型属性，它只指定属性的名称和类型。此外，协议还指定属性是可读的还是可读可写的。
如果协议要求属性是可读可写的，那么该属性不能是常量属性或只读的计算型属性。如果协议只要求属性是可读的，那么该属性不仅可以是可读的，如果代码需要的话，还可以是可写的。

//协议定义
protocol CompanyPersonProtocol
{
    var name: String{ get };
    var age: Int{ get set };
    static var companyName: String{ get };
}

//协议实现
class Company: CompanyPersonProtocol
{
    var name: String;
    var age: Int;
    static var companyName: String{
        return "LGF";
    };
    
    init(name: String, age: Int)
    {
        self.name = name;
        self.age = age;
    }
}

//使用
var company = Company(name: "GofLee", age: 30);
company.name = "LeeGof";
print("Name is \(company.name)");  //"Name is LeeGof\n"

3.方法要求

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

//协议定义
protocol RandomNumberGenerator
{
    func random() -> Double;  //实例方法
    static func description();  //类型方法
}

//协议实现
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;
    }
    
    static func description()
    {
        print("Hello");
    }
}

//使用
let generator = LinearCongruentialGenerator();
print("Here's a random number: \(generator.random())");  //"Here's a random number: 0.37464991998171\n"

4.Mutating 方法要求

有时需要在方法中改变方法所属的实例。例如，在值类型（即结构体和枚举）的实例方法中，将 mutating 关键字作为方法的前缀，写在 func 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。
特别注意：实现协议中的 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();
print("lightSwitch: \(lightSwitch)");  //"lightSwitch: On\n"

5.构造器要求

在采纳协议的类中实现构造器，无论是指定构造器还是便利构造器，都必须为构造器实现标上 required 修饰符。
和第三点类似，注意一个地方：如果类已经被标记为 final，那么不需要在协议构造器的实现中使用 required 修饰符，因为 final 类不能有子类。

protocol SomeProtocol
{
    init(someParameter: Int);
}

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

6.协议作为类型

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

作为函数、方法或构造器中的参数类型或返回值类型
作为常量、变量或属性的类型
作为数组、字典或其他容器中的元素类型

//协议定义
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;
    }
}

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());

7.委托（代理）模式

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

//委托定义
protocol WebServiceProtocol
{
    func requestSuccess(data: String);
    func requestFailed(error: String);
}

//委托实现
class LoginViewController: WebServiceProtocol
{
    func requestSuccess(data: String)
    {
        print("调用结果：\(data)");
    }
    
    func requestFailed(error: String)
    {
        print("\(error)");
    }
}

class WebServiceRequest
{
    var delegate: WebServiceProtocol;
    
    init(delegate: WebServiceProtocol)
    {
        self.delegate = delegate;
    }
    
    func userLogin(userName: String, password: String)
    {
        delegate.requestSuccess("调用成功");
    }
}

var loginVC = LoginViewController();
var webService = WebServiceRequest(delegate: loginVC);
webService.userLogin("aa", password: "bb");

8.通过扩展添加协议一致性

即便无法修改源代码，依然可以通过扩展令已有类型采纳并符合协议。通过扩展令已有类型采纳并符合协议时，该类型的所有实例也会随之获得协议中定义的各项功能。
这个在项目开发中比较常用，例如我们可以把UITableView的委托放在扩展中去实现，这样能更好的分离代码。

9.通过扩展采纳协议

当一个类型已经符合了某个协议中的所有要求，却还没有声明采纳该协议时，可以通过空扩展体的扩展来采纳该协议
释义：即使满足了协议的所有要求，类型也不会自动采纳协议，必须显式地采纳协议。

protocol TextRepresentable
{
    var textualDescription: String { get };
}

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\n"

10.协议类型的集合

协议类型可以在数组或者字典这样的集合中使用。

let things: [TextRepresentable] = [game, d12, simonTheHamster];  //数组中的变量都是实现了TextRepresentable的类型

11.协议的继承

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

//释义：任何采纳 InheritingProtocol 协议的类型在满足该协议的要求时，也必须满足 SomeProtocol、AnotherProtocol 协议的要求。
//伪代码
protocol InheritingProtocol: SomeProtocol, AnotherProtocol
{
    // 这里是协议的定义部分
}

12.类类型专属协议

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

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

13.协议合成

有时候需要同时采纳多个协议，你可以将多个协议采用 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>)
{
    print("Happy birthday \(celebrator.name) - you're \(celebrator.age)!");
}

let person = Person(name: "Gof", age: 30);
wishHappyBirthday(person);

14.检查协议一致性

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

is 用来检查实例是否符合某个协议，若符合则返回 true，否则返回 false。
as? 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 nil。
as! 将实例强制向下转换到某个协议类型，如果强转失败，会引发运行时错误。

protocol HasArea
{
    var area: Double { get };
}

class Country: HasArea
{
    var area: Double;
    init(area: Double)
    {
        self.area = area;
    }
}

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

let country = Country(area: 243_610);
let animal = Animal(legs: 4);

country is HasArea;  //true
country as? HasArea;  //Country
animal as? HasArea;  //nil
//animal as! HasArea;  //错误

15.可选的协议要求

在协议中使用 optional 关键字作为前缀来定义可选要求。使用可选要求时（例如，可选的方法或者属性），它们的类型会自动变成可选的。比如，一个类型为 (Int) -> String 的方法会变成 ((Int) -> String)?。
协议中的可选要求可通过可选链式调用来使用，因为采纳协议的类型可能没有实现这些可选要求。

【特别注意】：

可选的协议要求只能用在标记 @objc 特性的协议中。该特性表示协议将暴露给 Objective-C 代码，即使你不打算和 Objective-C 有什么交互，如果你想要指定可选的协议要求，那么还是要为协议加上 @objc 特性。
标记 @objc 特性的协议只能被继承自 Objective-C 类的类或者 @objc 类采纳，其他类以及结构体和枚举均不能采纳这种协议。

import Foundation

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

//这里注意ThreeSource继承自NSObject类，如果不继承自NSObject类，会怎样提示呢？
class ThreeSource: NSObject, CounterDataSource
{
    let fixedIncrement = 3;
}

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

var counter = Counter();
counter.dataSource = ThreeSource();
counter.increment();
print(counter.count);

16.协议扩展

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

protocol RandomNumberGenerator
{
    func random() -> Double;
}

extension RandomNumberGenerator
{
    func randomBool() -> Bool
    {
        return random() > 0.5;
    }
}

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())");
print("And here's a random Boolean: \(generator.randomBool())");

posted @ 2016-07-18 21:56 LeeGof 阅读(322) 评论(0) 编辑收藏举报

刷新页面返回顶部

LeeGof

大道至简