继承和组合的缺点
在开发工作中，继承总是用来在多个类之间共享代码。
设想一个场景，一个人类，可以说话和睡觉，而一个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 bricks
let robot = Robot(name: T1000)
robot.work() // T1000 is working
let feifei = Cat(name: "feifei")
feifei.say() // meow~
小结
不同于OC， Swift里大量使用了protocol， 在OC中，protocol仅限用于NSObject的子类， 而Swift则不同， protocol可以被任何类型实现，点进Swift的各个基本类型，可以看到它们都实现了各式协议，这使它们功能比其他的语言更加强大，拓展性更是如此。 Swift 的 extension 也比OC的强大的多，protocol 和 extension配合起来， 做到了更大的灵活性，实现更加强大的功能， 比起继承和组合更加有效。
网友评论