Swift的协议默认实现_app

概述继承和组合的缺点带默认实现的协议小结继承和组合的缺点在开发工作中，继承总是用来在多个类之间共享代码。设想一个场景，一个人类，可以说话和睡觉，而一个Worker，除了上述功能，还可以工作。解决方案很简单，我们可以 Person 和 Worker 之间建立继承关系： class Person { func say() { print("hello") } 继承和组合的缺点带默认实现的协议小结继承和组合的缺点

在开发工作中，继承总是用来在多个类之间共享代码。
设想一个场景，一个人类，可以说话和睡觉，而一个Worker，除了上述功能，还可以工作。
解决方案很简单，我们可以 Person 和 Worker 之间建立继承关系：

class Person {    func say() {         print("hello")    }    func sleep() {         print("I'm sleePing")    }}class Worker: Person {    func work() {         print("I'm carrying bricks")    }}

在随后的开发中，可能一个新的类型 Robot，也可以工作了，这个时候我们不能使用 Worker 了，因为很明显， Robot不可能同时是一个Person。
解决这个问题，我们可能尝试组合的方式，通过公共类管理 work 行为：

class WorkManager {    func work() {         print("I'm carrying bricks")    }}class Worker: Person {    let workManager = WorkManager()    func work() {         workManager.work()    }}class Robot: Machine {    let workManager = WorkManager()    func work() {         workManager.work()    }}

这样做的缺点也显而易见，代码虽然复用了，可是类结构也变的臃肿，每次都要引用 WorkManager 。

带默认实现的协议

在Swift2.0里在定义一个协议protocol时，还能使用extension给它的某些方法做默认实现：

protocol Workable {  func work()}extension Workable {  func work() {    print("I'm carrying bricks")  }}

有了上面的代码，当你创建一个遵从 Workable 协议的类或者是结构体时，就能获得 work() 方法
这只是一个默认的实现方式。因此你可以在需要的时候重新定义这个方法；如果不重新定义的话，会使用这个默认方法。
使用这种方式，可以大大简化我们的代码，我们甚至什么都不需做，指定继承关系就完成了工作：

class Worker: Person,Workable {}class Robot: Machine,Workable {}...let worker = Worker()let robot = Robot()worker.work() // I'm carrying bricks robot.work() // I'm carrying bricks

当然我们也可以设定协议依赖的数据，比如work依赖对象的名字：

protocol Workable {    var name: String { get }    func work()}extension Workable {  func work() {    print("\(name) is carrying bricks")  }}class Worker: Person,Workable {    var name: String    init(name: String) {        self.name = name    }}...let worker = Worker("TIEzhu")worker.work() // TIEzhu is carrying bricks

现在可以按照功能重新划分protocol，并开启积木模式了，首先拆分 Person ：

protocol Sayable {    var words: String { get }    func say()}extension Sayable {  func say() {    print("\(words)")  }}protocol Sleepable {    var name: String { get }    func sleep()}extension Sleepable {  func sleep() {        print("\(name) is sleePing")  }}

enjoy it ：

class Person: Sayable,Sleepable {}class Worker: Person,Workable {    var name: String    var words = "hello"    init(name: String) {        self.name = name    }}class Robot: Sayable,Workable {    var name: String    var words = "..."    init(name: String) {        self.name = name    }}class Cat: Sayable,Sleepable {    var name: String    var words = "meow~"    init(name: String) {        self.name = name    }}...let tIEzhu = Worker(name: TIEzhu)tIEzhu.work() // TIEzhu is carrying brickslet robot = Robot(name: T1000)robot.work() // T1000 is workinglet feifei = Cat(name: "feifei")feifei.say() // meow~

小结

不同于OC， Swift里大量使用了protocol，在OC中，protocol仅限用于NSObject的子类，而Swift则不同， protocol可以被任何类型实现，点进Swift的各个基本类型，可以看到它们都实现了各式协议，这使它们功能比其他的语言更加强大，拓展性更是如此。 Swift 的 extension 也比OC的强大的多，protocol 和 extension配合起来，做到了更大的灵活性，实现更加强大的功能，比起继承和组合更加有效。