组合Composition（has-a）

在 Python 中，**组合（Composition）** 是一种设计模式，用于将一个类的实例作为另一个类的属性。这种模式允许你将多个类的功能组合在一起，而不是通过继承来实现。组合强调的是“有一个”（has-a）关系，而不是“是一个”（is-a）关系。

### **1. 组合的基本概念**
组合是一种将一个类的实例作为另一个类的属性的方式。这种方式可以让你在不使用继承的情况下，将多个类的功能组合在一起。

### **2. 组合与继承的区别**
- **继承（Inheritance）**：
  - 表示“是一个”（is-a）关系。
  - 子类继承父类的所有属性和方法。
  - 例如，`Dog` 是 `Animal` 的一种。

- **组合（Composition）**：
  - 表示“有一个”（has-a）关系。
  - 一个类的实例作为另一个类的属性。
  - 例如，`Car` 有一个 `Engine`。

### **3. 组合的示例**

#### 示例 1：简单的组合
```python
class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()  # Car 有一个 Engine

    def start(self):
        print("Car started")
        self.engine.start()  # 调用 Engine 的 start 方法

# 创建 Car 实例
my_car = Car()
my_car.start()
```

输出：
```
Car started
Engine started
```

在这个例子中：
- `Car` 类有一个 `Engine` 实例作为属性。
- `Car` 的 `start` 方法调用了 `Engine` 的 `start` 方法。

### **4. 组合的高级用法**

#### 示例 2：组合多个类
```python
class Engine:
    def start(self):
        print("Engine started")

class Wheel:
    def rotate(self):
        print("Wheel rotating")

class Car:
    def __init__(self):
        self.engine = Engine()  # Car 有一个 Engine
        self.wheels = [Wheel() for _ in range(4)]  # Car 有四个 Wheel

    def start(self):
        print("Car started")
        self.engine.start()  # 调用 Engine 的 start 方法

    def drive(self):
        print("Car driving")
        for wheel in self.wheels:
            wheel.rotate()  # 调用每个 Wheel 的 rotate 方法

# 创建 Car 实例
my_car = Car()
my_car.start()
my_car.drive()
```

输出：
```
Car started
Engine started
Car driving
Wheel rotating
Wheel rotating
Wheel rotating
Wheel rotating
```

在这个例子中：
- `Car` 类有一个 `Engine` 实例和四个 `Wheel` 实例作为属性。
- `Car` 的 `start` 方法调用了 `Engine` 的 `start` 方法。
- `Car` 的 `drive` 方法调用了每个 `Wheel` 的 `rotate` 方法。

### **5. 组合的优点**
1. **灵活性**：
   - 组合允许你在运行时动态地组合对象，而继承则在编译时固定。
   - 例如，你可以根据需要为 `Car` 添加不同类型的 `Engine` 或 `Wheel`。

2. **可维护性**：
   - 组合使得代码更加模块化，每个类的职责更加明确。
   - 例如，`Engine` 和 `Wheel` 可以独立于 `Car` 进行开发和维护。

3. **避免继承层次过深**：
   - 过多的继承层次可能导致代码难以理解和维护。
   - 组合可以避免这些问题，使代码结构更加清晰。

### **6. 组合的缺点**
1. **复杂性**：
   - 组合可能会增加代码的复杂性，特别是当组合的对象较多时。
   - 例如，`Car` 类需要管理多个 `Wheel` 和一个 `Engine`，这可能会增加代码的复杂性。

2. **性能**：
   - 组合可能会导致更多的对象创建和方法调用，从而影响性能。
   - 例如，`Car` 的 `start` 方法需要调用 `Engine` 的 `start` 方法，这可能会增加一些开销。

### **7. 使用场景**
1. **功能组合**：
   - 当你需要将多个类的功能组合在一起时，组合是一个很好的选择。
   - 例如，`Car` 需要 `Engine` 和 `Wheel` 的功能。

2. **避免继承层次过深**：
   - 当继承层次过深时，可以使用组合来简化代码结构。
   - 例如，`Car` 可以组合 `Engine` 和 `Wheel`，而不是通过继承。

3. **动态组合**：
   - 当你需要在运行时动态地组合对象时，组合是一个很好的选择。
   - 例如，`Car` 可以根据需要添加不同类型的 `Engine` 或 `Wheel`。

### **8. 总结**
- **组合**：将一个类的实例作为另一个类的属性，表示“有一个”（has-a）关系。
- **继承**：表示“是一个”（is-a）关系，子类继承父类的所有属性和方法。
- **选择**：根据实际需求选择合适的模式。组合通常更灵活，但可能会增加代码的复杂性。