组合模式_结构型_GOF23

组合模式

组合模式（Composite Pattern）是一种结构型设计模式，核心思想是将对象组织成树形结构，使客户端能以统一方式处理单个对象和组合对象。这类似于文件系统的设计——用户对文件和文件夹的操作（如复制、删除）具有一致性，尽管它们的内部结构完全不同。

一、通俗理解

想象你管理一家公司的组织架构：

传统方式：需要分别处理“部门”和“员工”两种对象，代码中充斥 if-else 判断。
组合模式：
- 抽象组件：定义所有对象的通用接口（如 display()）。
- 叶子节点：员工（无下属）。
- 组合节点：部门（可包含其他部门或员工）。
  无论操作单个员工还是整个部门，客户端只需调用 display() 方法，无需关心具体类型。

二、模式结构

Component（抽象组件）：定义通用接口（如 add()、remove()、operation()）。
Leaf（叶子节点）：实现组件接口，代表树形结构的末端元素（如文件）。
Composite（组合节点）：实现组件接口，包含子组件集合（如文件夹）。

三、适用场景

树形结构数据：文件系统、公司组织架构、GUI组件（窗口包含面板和按钮）。
统一操作需求：需要以相同方式处理单个对象和组合对象（如统计文件夹大小）。
动态层次结构：对象结构可能频繁变化（如动态增减部门）。

不适用场景：

对象结构无层次关系（如线性链表）。
需要高性能处理的底层系统（递归遍历可能影响效率）。

四、代码实现

1. C++ 示例（文件系统）

#include <iostream>  
#include <vector>  
#include <memory>  // 抽象组件  
class FileSystemComponent {  
public:  virtual void display(int indent = 0) const = 0;  virtual ~FileSystemComponent() = default;  
};  // 叶子节点：文件  
class File : public FileSystemComponent {  std::string name;  
public:  File(const std::string& name) : name(name) {}  void display(int indent) const override {  std::cout << std::string(indent, ' ') << "📄 " << name << std::endl;  }  
};  // 组合节点：文件夹  
class Folder : public FileSystemComponent {  std::string name;  std::vector<std::unique_ptr<FileSystemComponent>> children;  
public:  Folder(const std::string& name) : name(name) {}  void add(std::unique_ptr<FileSystemComponent> component) {  children.push_back(std::move(component));  }  void display(int indent) const override {  std::cout << std::string(indent, ' ') << "📁 " << name << std::endl;  for (const auto& child : children) {  child->display(indent + 2);  }  }  
};  // 客户端  
int main() {  auto root = std::make_unique<Folder>("Root");  auto docs = std::make_unique<Folder>("Documents");  docs->add(std::make_unique<File>("resume.pdf"));  docs->add(std::make_unique<File>("notes.txt"));  root->add(std::move(docs));  root->display();  
}

输出：

📁 Root  📁 Documents  📄 resume.pdf  📄 notes.txt

解析：

文件夹（Composite）递归调用子组件的 display() 方法。
使用智能指针管理内存，避免泄漏。

2. Python 示例（公司组织架构）

from abc import ABC, abstractmethod  class OrganizationComponent(ABC):  @abstractmethod  def display(self, indent=0):  pass  class Employee(OrganizationComponent):  def __init__(self, name):  self.name = name  def display(self, indent=0):  print(" " * indent + f"👤 {self.name}")  class Department(OrganizationComponent):  def __init__(self, name):  self.name = name  self.children = []  def add(self, component):  self.children.append(component)  def display(self, indent=0):  print(" " * indent + f"🏢 {self.name}")  for child in self.children:  child.display(indent + 2)  # 客户端  
if __name__ == "__main__":  tech_dept = Department("技术部")  tech_dept.add(Employee("张三"))  tech_dept.add(Employee("李四"))  company = Department("总公司")  company.add(tech_dept)  company.display()

输出：

🏢 总公司  🏢 技术部  👤 张三  👤 李四

特点：

Python动态语言特性简化接口继承。

3. Java 示例（图形界面组件）

import java.util.ArrayList;  
import java.util.List;  // 抽象组件  
interface GUIComponent {  void render(int indent);  
}  // 叶子节点：按钮  
class Button implements GUIComponent {  private String label;  public Button(String label) { this.label = label; }  public void render(int indent) {  System.out.println(" ".repeat(indent) + "🖱️ " + label);  }  
}  // 组合节点：面板  
class Panel implements GUIComponent {  private List<GUIComponent> children = new ArrayList<>();  private String name;  public Panel(String name) { this.name = name; }  public void add(GUIComponent component) {  children.add(component);  }  public void render(int indent) {  System.out.println(" ".repeat(indent) + "🖼️ " + name);  for (GUIComponent child : children) {  child.render(indent + 2);  }  }  
}  // 客户端  
public class Client {  public static void main(String[] args) {  Panel mainPanel = new Panel("主面板");  mainPanel.add(new Button("确定"));  mainPanel.add(new Button("取消"));  Panel root = new Panel("窗口");  root.add(mainPanel);  root.render(0);  }  
}

输出：

🖼️ 窗口  🖼️ 主面板  🖱️ 确定  🖱️ 取消

应用场景：

复杂UI布局的统一渲染。

五、优缺点分析

优点	缺点
1. 统一处理：客户端代码简洁易维护	1. 接口污染：叶子节点被迫实现无意义方法（如 `add()`）
2. 扩展性强：新增组件类型无需修改旧代码	2. 性能问题：深层嵌套导致递归效率低
3. 层次清晰：天然支持树形结构操作	3. 设计复杂：需处理父子节点循环引用