ios - 共享变量的组合而不是继承

Question

我之前使用的类可以简化为:

class Whatever {

  var someArray = [Int]()

  func unchangingFunction {
    print("test")
  }

  func functionForOverride() {}

}

我在询问如何改进这一点，我被告知要使用类似以下的方法来支持组合而不是继承:

protocol Implementation {
  func functionForOverride()
}

final class Whatever {

  var someArray = [Int]() // How can I access this?

  let implementation: Implementation

  init(implementation: Implementation) {
    self.implementation = implementation
  }

  func unchangingFunction() {
    print("test")
  }

  func functionForOverride() {
    implementation.functionForOverride()
  }

}

但是，有了这个，我找不到对 someArray 数组做任何事情的方法:

struct Something: Implementation {

  func functionForOverride() {
    print(someArray) // This cannot work
  }

}

使用原始代码，我可以随心所欲地访问和更改 someArray，但是使用这种新方法，我想不出一个简单的解决方案。

Answer 1

我认为我们应该使用一个“真实”的例子来使事情更清楚。

继承(及其错误原因)

我们有以下类(class)

class Robot {
    var battery = 0

    func charge() {
        print("⚡️")
        battery += 1
    }
}

class Human {
    func eat() {
        print("🍽")
    }
}

class RobotCleaner: Robot {
    func clean() {
        print("💧")
    }
}

class HumanCleaner: Human {
    func clean() {
        print("💧")
    }
}

代码重复!!!

如您所见，clean() 方法在 RobotCleaner 和 HumanCleaner 中重复。你能找到一种方法(使用继承)来消除代码重复吗？

好的，考虑一下，我会等下一段......:)

...

哦，你来了!没有办法用继承来解决这个问题吗？好吧，让我们看看我们可以用组合做什么。

组合(经典方式)

让我们定义以下 3 个协议(protocol)和相关组件

protocol Robot {
    mutating func charge()
}
struct RobotComponent: Robot {
    var battery = 0
    mutating func charge() {
        print("⚡️")
        battery += 1
    }
}

protocol Human {
    func eat()
}
struct HumanComponent: Human {
    func eat() {
        print("🍽")
    }
}

protocol Cleaner {
    func clean()
}
struct CleanerComponent: Cleaner {
    func clean() {
        print("💧")
    }
}

现在我们可以构建前面 3 个元素的任意组合

struct RobotCleaner: Robot, Cleaner {
    var robotComponent = RobotComponent()
    let cleanerComponent = CleanerComponent()

    mutating func charge() {
        robotComponent.charge()
    }

    func clean() {
        cleanerComponent.clean()
    }

}

struct HumanCleaner: Human, Cleaner {
    let humanComponent = HumanComponent()
    let cleanerComponent = CleanerComponent()

    func eat() {
        humanComponent.eat()
    }

    func clean() {
        cleanerComponent.clean()
    }   
}

面向协议(protocol)编程:以 Swifty 方式组合

Swift 提供了一种非常简洁的组合方式。

首先让我们定义以下 3 个协议(protocol)(和相关扩展)。

protocol Robot {
    var battery: Int { get set }
}
extension Robot {
    mutating func charge() {
        print("⚡️")
        battery += 1
    }
}

protocol Human { }
extension Human {
    func eat() {
        print("🍽")
    }
}

protocol Cleaner { }
extension Cleaner {
    func clean() {
        print("💧")
    }
}

现在我们可以创建一个具有前 3 个实体的任意组合的类型。让我们看看如何。

struct HumanCleaner: Human, Cleaner { }
struct RobotCleaner: Robot, Cleaner {
    var battery: Int = 0
}