作为Swift中的一种自定义类型，和struct，class、enum不同，我们使用protocol来定义某种约定，而不是某一个具体的类型，这种约定通常用于表示某些类型的共性
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
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)
尽管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<Rational> = []
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
