Swift中的Protocol

作为Swift中的一种自定义类型，和struct，class、enum不同，我们使用protocol来定义某种约定，而不是某一个具体的类型，这种约定通常用于表示某些类型的共性

protocol.png

protocol Engine{
    var cylinder : Int{ get set} //可读写
    var capacity: Double { get }
    func start()
    func stop()
    /*
     当protocol中的方法带有参数时，参数是不能有默认值的。
     如果我们希望把“提供有默认参数版本的方法”也作为一种约定，
     我们只能像下面这样单独定义一个不带任何参数的方法。
     例如我们要添加一个生成引擎名称的方法：
     */
    func getName(prefix: String) //默认不能添加默认值
    func getName()
}

protocol也是可以继承的

和class的继承类似，protocol也支持继承，用于表示“约定A” is A "约定B"这样的语意。

protocol TurborEngine:Engine{
    func startTurbo()
    func stopTurbo()
}

class V8 : TurborEngine {
    
    var cylinder = 8
    private var innerCapacity: Double = 4.0
    
    var capacity: Double {
        get {
            return self.innerCapacity
        }
        set {
            self.innerCapacity = newValue
        }
    }
    func start(){print("Engine started")}
    
    func stop(){print("Engine stopped")}
    
    func getName(prefix: String){
        print("Engine V8")
    }
    
    func getName(){
        print("Engine V8")
    }
    
    func startTurbo() {
        print("Engine Turbo started")
    }
    
    func stopTurbo() {
        print("Engine Turbo stopped")
    }
}

let v8L40 = V8()
v8L40.cylinder
v8L40.cylinder = 8
v8L40.capacity
v8L40.capacity = 8

“遵从”多个protocol的约定

除了“遵从”单一protocol之外，我们还可以让一个自定义类型“遵从”多个protocol。例如我们添加一个新的protocol，表示“电动机”的约定：

protocol Motor {
    var power: Double { get set }
}

多个protocol.png

使用标准库中的protocol

let a: Int = 10
let b: Int = 10

let d1: Double = 3.14
let d2: Double = 3.14

/*a和b，d1和d2都是相等的。
   但是，如果我们自定义了一个表示分数的struct：
*/
struct Rational {
    var numerator: Int
    var denominator: Int
}

let oneHalf = Rational(numerator: 1, denominator: 2)
let zeroPointTwo = Rational(numerator: 1, denominator: 2)

equatable

尽管1/2和0.5是相等的，但为了能够比较Rational对象，我们必须明确告诉Swift编译器：“判断两个Rational对象相等的标准是什么”。而Swift为我们提供了一个标准的protocol - Equatable，我们通过实现它来告诉Swift自定义类型的比较标准。

extension Rational :Equatable{}

func == (lhs:Rational ,rhs:Rational) -> Bool {
    let equalNumerator = lhs.numerator == rhs.numerator
    let equalDenominator = lhs.denominator == rhs.denominator
     return equalNumerator && equalDenominator
}

我们通过上面的方法告诉Swift，如果两个Rational对象的分子和分母都相等，那么两个Rational对象是相等的。这样，之前oneHalf和zeroPointTwo的比较就不会报错了。

除了比较相等之外，Swift还提供了比较大小的protocol - Comparable，它继承自Equatable，并提供了"<"，"<="，">"，">="四个方法。我们添加下面的代码，让Rational支持各种比较操作。首先，把Equatable修改为Comparable，这样Swift编译器会提示我们Rational没有满足Comparable的约定：

extension Rational: Comparable {}
func < (lhs: Rational, rhs: Rational) -> Bool {
    let lQuotient =
        Double(lhs.numerator) / Double(lhs.denominator)
    let rQuotient =
        Double(rhs.numerator) / Double(rhs.denominator)
    
    return lQuotient < rQuotient
}

在实现了Comparable之后，除了可以对Rational进行比较之外，还有一些额外的"福利"。当我们把Rational对象放入支持Comparable的集合类型时，例如Array，集合的各种排序，比较，包含操作，就可以对Rational对象生效了。例如：

var rationals: Array = []

for i in 1...10 {
    var r = Rational(numerator: i, denominator: i+1)
    rationals.append(r)
}

print("Max in rationals: \(rationals.maxElement()!)")
print("Min in rationals: \(rationals.minElement()!)")
rationals.startsWith([oneHalf])
rationals.contains(oneHalf)

自定义类型的print

在上面的结果里，我们可以看到print打印Rational的字符串：Rational(numerator: 10, denominator: 11)。这看上去很啰嗦，如果我们希望像一个分数一样打印Rational，可以实现Swift提供的CustomStringConvertible protocol：

/*
 CustomStringConvertible只有一个约定：定义一个名为description的属性。
 这样，上面的print结果就变成了这样：
 */
extension Rational : CustomStringConvertible {
    var description: String {
        return "\(self.numerator) / \(self.denominator)"
    }
}

认识protocol extension

通过extension添加额外功能

在我们之前的几个视频中，protocol始终被我们当作"接口"来使用，它定义了其它自定义类型要实现的属性和方法。不过现在，是时候改变这个认识了，在Swift里，protocol也是可以提供默认实现的。来看一个例子，我们定义一个描述航班的protocol：

protocol Flight {
    var delay: Int { get }
    var normal: Int { get }
    var flyHour: Int { get }
}

它的前两个属性表示航班延误和准点的次数，flyHour表示航班总飞行时间。这时，如果我们想计算航班的总飞行次数，可以通过定义一个protocol extension来实现：

extension Flight {
    var totalTrips: Int {
        return delay + normal
    }
}

扩展一个protocol看似和扩展其它自定义类型没有太大区别，都是使用extension关键字，加上要扩展的类型的名字。但是，和定义protocol不同，我们可以在一个protocol extension中提供默认的实现。尽管此时我们还没有定义任何"遵从"Flight的类型，但是我们已经可以在extension中使用Flight的数据成员了。因为Swift编译器知道，任何一个"遵从"Fligh的自定义类型，一定会定义Flight约定的各种属性。

例如，我们定义一个表示"空客A380"客机的类型：

struct A380: Flight {
    var delay: Int
    var normal: Int
    var flyHour: Int
}

然后，当我们定义了一个A380对象之后，就可以使用totolTrips获取总飞行次数了：

let flight1 = A380(delay: 300, normal: 700, flyHour: 5 * 365 * 24)
flight1.totalTrips // 1000
通过extension为protocol方法提供默认实现

通过这个简单的例子，我们了解了如何使用extension为一个protocol添加额外的默认功能。除此之外，我们还可以使用extension为protocol的已有方法提供默认实现。例如，我们给Flight添加一个计算晚点率的方法：

protocol Flight {
    var delay: Int { get }
    var normal: Int { get }
    var flyHour: Int { get }
    
    func delayRate() -> Double
}

然后，我们可以在extension里，添加一个delayRate的默认实现：

extension Flight {
    var totalTrips: Int {
        return delay + normal
    }
    
    func delayRate() -> Double {
        return Double(delay) / Double(totalTrips)
    }
}

这样，A380的对象就可以自动获得这个接口了：

let flight1 = A380(delay: 300, normal: 700, flyHour: 5 * 365 * 24)
flight1.delayRate() // 0.3

一切都看似很简单，extension即可以为protocol添加额外的功能，又可以为已有的方法提供默认实现。但是，这两种行为，却有着细微的差别，简单来说：通过extension添加到protocol中的内容，不算做protocol约定，我们来看个例子：

首先，我们在A380中，为delayRate()添加一个自定义实现：

struct A380: Flight {
    var delay: Int
    var normal: Int
    var year: Int
    
    func delayRate() -> Double {
        return 0.1
    }
}

然后，无论flight1的类型是Flight还是A380，我们可以看到delayRate()的输出都将变成0.1：

let flight1 = A380(delay: 300, normal: 700, flyHour: 5 * 365 * 24)
flight1.delayRate()                  // 0.1
(flight1 as! Flight).delayRate() // 0.1

这是符合我们预期的，因为我们在A380中重定义了Flight中约定的方法。接下来，我们在Flight中注释掉delayRate()：

protocol Flight {
    var delay: Int { get }
    var normal: Int { get }
    var year: Int { get }
    
    // func delayRate() -> Double
}

这时，就可以看到当flight1的类型为A380时，delayRate()的结果是0.1；而flight1的类型为Flight时，delayRate()的结果是0.3。

这是因为当我们在Flight中注释掉delayRate()时，它就不在是Flight约定的一部分了。在extension中实现的delayRate()只不过是为Flight提供的一个便利功能。既然delayRate()不再是约定，Swift编译器也不会"感知"到A380对delayRate()的重定义，而只是把delayRate()理解为是A380定义的一个普通的方法。因此，我们把flight1的类型转换Flight时，Swift就会调用Flight版本的delayRate了。实际上，Flight和A380中的delayRate()没有任何关系。

在extension中使用type constraints

除了在extension中提供默认实现之外，我们还可以为默认实现限定可用的条件。这个限定的方式，就叫做type constraints。来看个例子：

例如，我们定义一个用于约定飞机服务年限的protocol：

protocol OperationalLife {
    var maxFlyHours: Int { get }
}

然后，我们使用extension给"所有遵从OperationalLife的Flight"添加一个默认实现：

extension Flight where Self: OperationalLife {
    func isInService() -> Bool {
        return self.flyHour < maxFlyHours
    }
}

在上面的代码里，where表示我们要进行一个type contraints，Self表示"最终遵从protocol的类型"（在我们的例子里，也就是A380）。所以整个表达式的含义就是当某个类型同时遵从OperationalLife和Flight时，扩展Flight，并提供isInService方法。
然后，我们让A380遵从OperationalLife：

extension A380: OperationalLife {
    var maxFlyHours: Int {
        return 18 * 365 * 24
    }
}

“我们不能在一个extension中定义stored property，因此，这里我们把maxFlyHours实现成了一个computed property。”

特别提示
然后，flight1就可以使用isInService()方法了。

let flight1 = A380(delay: 300, normal: 700, flyHour: 5 * 365 * 24)
flight1.isInService() // true