在Swift中进行面向对象编程时，尽量使用协议和泛型，而不是类继承，因为过深的继承层次很容易让代码充满难以理解的类。

协议扩展

前面我们介绍过了类的扩展，协议的扩展也是类似的，协议扩展可以添加现有的计算属性和方法，不能添加存储属性。扩展不会增加协议的需求。
下面的代码中，所有实现Worker协议的结构体都获得了一个getDesc方法。

protocol Worker {
    var job:String {get}
    var workTime:Int{get}
}


struct Teacher:Worker {
    let job="teacher"
    let workTime=8
}


struct Coder:Worker {
    let job="coder"
    let workTime=10
}

extension Worker{
    func getDesc()-> String{
        return "I am a \(job),I work \(workTime) hours everday"
    }
}

var coder=Coder()
print(coder.getDesc())

带where子句的协议扩展

和泛型一样，协议也能使用where子句进行类型限制，下面的代码扩展了Sequence协议，使数组元素为Worker时新增一个printAllWorker方法。

extension Sequence where Iterator.Element == Worker{
    func printAllWorker(){
        for worker in self {
            print(worker.getDesc())
        }
    }
}


let workers:[Worker]=[Coder(),Teacher()]
workers.printAllWorker()

协议扩展的覆盖

在Coder类型中可以使用同名方法覆盖协议扩展中的方法，不过当Coder当做一个Worker来使用的时候还是会调用Worker中的方法。

struct Coder:Worker {
    let job="coder"
    let workTime=10
    func getDesc()-> String{
        return "hello world"
    }
}

let workers:[Worker]=[Coder(),Teacher()]
//I am a coder,I work 10 hours everday
//I am a teacher,I work 8 hours everday
workers.printAllWorker()

//hello world
let coder=Coder()
print(coder.getDesc())