组合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）关系，子类继承父类的所有属性和方法。
- **选择**：根据实际需求选择合适的模式。组合通常更灵活，但可能会增加代码的复杂性。