组合模式（Composite Pattern）是一种结构型设计模式，它允许将对象组合成树形结构以表示“部分-整体”的层次结构-CSDN博客

组合模式（Composite Pattern）是一种结构型设计模式，它允许将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。这种模式特别适用于处理具有层级关系的场景，如文件系统、组织结构、图形界面等。

1. 组合模式的主要角色

组件接口（Component）：定义了组合中对象的行为，可以包括操作方法和管理子对象的方法。
叶子组件（Leaf）：表示组合中的叶子节点，没有子节点，实现组件接口的具体操作。
组合组件（Composite）：表示组合中的分支节点，包含子节点，实现组件接口，并提供添加、删除子节点的方法。
客户端代码：使用组件接口来操作组合结构中的对象，无需关心对象是叶子节点还是组合节点。

2. 组合模式的实现步骤

定义组件接口：声明组合中对象的行为，包括操作方法和管理子对象的方法。
实现叶子组件类：实现组件接口，表示组合中的叶子节点。
实现组合组件类：实现组件接口，表示组合中的分支节点，提供添加、删除子节点的方法。
客户端代码：通过组件接口操作组合结构中的对象。

3. 示例代码

假设我们有一个文件系统，包含文件和文件夹。文件夹可以包含文件和其他文件夹，文件夹和文件都具有显示内容的功能。我们可以使用组合模式来实现这个需求。

3.1 定义组件接口

public interface FileSystemComponent {
    void display();
}

3.2 实现叶子组件类（文件）

public class File implements FileSystemComponent {
    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public void display() {
        System.out.println("文件: " + name);
    }
}

3.3 实现组合组件类（文件夹）

import java.util.ArrayList;
import java.util.List;

public class Folder implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components = new ArrayList<>();

    public Folder(String name) {
        this.name = name;
    }

    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    public void removeComponent(FileSystemComponent component) {
        components.remove(component);
    }

    @Override
    public void display() {
        System.out.println("文件夹: " + name);
        for (FileSystemComponent component : components) {
            component.display();
        }
    }
}

3.4 客户端代码

public class Main {
    public static void main(String[] args) {
        // 创建文件和文件夹
        File file1 = new File("file1.txt");
        File file2 = new File("file2.txt");
        Folder folder1 = new Folder("folder1");
        Folder folder2 = new Folder("folder2");

        // 组合文件和文件夹
        folder1.addComponent(file1);
        folder1.addComponent(file2);
        folder2.addComponent(folder1);
        folder2.addComponent(new File("file3.txt"));

        // 显示文件系统结构
        folder2.display();
    }
}

4. 输出结果

运行客户端代码，输出结果如下：

文件夹: folder2
文件夹: folder1
文件: file1.txt
文件: file2.txt
文件: file3.txt

5. 组合模式的优点

一致性：客户端代码可以一致地处理单个对象和组合对象，无需关心对象的具体类型。
灵活性：可以灵活地添加或删除组合中的对象，支持动态组合。
符合开闭原则：对扩展开放，对修改封闭，无需修改现有代码即可添加新功能。

6. 适用场景

组合模式适用于以下场景：

当需要表示对象的部分-整体层次结构时。
当希望客户端代码可以一致地处理单个对象和组合对象时。
当需要动态地添加或删除组合中的对象时。

通过组合模式，可以清晰地表示对象的层次结构，使得代码更加模块化、易于维护和扩展。
组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构以表示“部分-整体”的层次关系。组合模式使得用户对单个对象和组合对象的使用具有一致性，即在大多数情况下可以忽略对象是单个元素还是组合结构。

核心概念

组件（Component）：定义组合中所有对象的通用接口，声明访问和管理子组件的方法。
叶节点（Leaf）：表示组合中的叶子节点对象，没有子节点，实现组件接口的基本行为。
组合节点（Composite）：表示组合中的分支节点对象，包含子组件，实现组件接口中管理子组件的方法。
客户端（Client）：通过组件接口操作组合结构中的对象。

主要作用

统一处理单个对象和组合对象：客户端可以一致地使用组合结构和单个对象，无需区分。
简化客户端代码：客户端无需关心处理的是单个对象还是组合结构，降低了客户端的复杂度。
灵活的树形结构：可以轻松地添加或删除组件，构建复杂的树形结构。

典型场景

表示“部分-整体”层次结构：如文件系统、组织结构图、菜单系统等。
需要统一处理组合对象和单个对象：当客户端需要忽略组合对象与单个对象的差异时。
递归遍历树形结构：组合模式天然支持递归遍历，可以方便地实现对整个结构的操作。

示例结构

下面是组合模式的一个简单示例结构（Python 伪代码）：

from abc import ABC, abstractmethod

# 组件接口
class Component(ABC):
    @abstractmethod
    def operation(self):
        pass
    
    def add(self, component):
        pass
    
    def remove(self, component):
        pass
    
    def get_child(self, index):
        pass


# 叶节点
class Leaf(Component):
    def operation(self):
        return "Leaf"


# 组合节点
class Composite(Component):
    def __init__(self):
        self.children = []
    
    def operation(self):
        results = []
        for child in self.children:
            results.append(child.operation())
        return f"Composite({'+'.join(results)})"
    
    def add(self, component):
        self.children.append(component)
    
    def remove(self, component):
        self.children.remove(component)
    
    def get_child(self, index):
        return self.children[index]


# 客户端代码
if __name__ == "__main__":
    # 创建叶节点
    leaf1 = Leaf()
    leaf2 = Leaf()
    
    # 创建组合节点
    composite1 = Composite()
    composite1.add(leaf1)
    composite1.add(leaf2)
    
    # 创建更大的组合节点
    leaf3 = Leaf()
    composite2 = Composite()
    composite2.add(composite1)
    composite2.add(leaf3)
    
    # 统一调用操作
    print(composite2.operation())  # 输出: Composite(Composite(Leaf+Leaf)+Leaf)

优点

简化客户端代码：客户端可以一致地使用组合结构和单个对象，无需进行区分。
易于扩展：可以很容易地添加新的组件类型，符合开闭原则。
灵活的结构：可以动态地添加或删除组件，构建复杂的树形结构。

缺点

限制类型安全性：可能会为叶节点添加子节点方法，导致运行时错误。
设计难度：设计抽象组件接口时需要考虑所有可能的操作，可能会导致接口变得复杂。
性能问题：在处理大型组合结构时，递归调用可能会导致性能问题。

与其他模式的区别

组合模式 vs 装饰器模式：
- 组合模式：关注“部分-整体”的层次结构，允许客户端统一处理单个对象和组合对象。
- 装饰器模式：关注在不改变对象结构的前提下动态添加功能。
组合模式 vs 享元模式：
- 组合模式：强调对象的组合结构，通常包含多个不同的对象。
- 享元模式：强调对象的共享，通过复用对象来减少内存消耗。

组合模式在实际开发中常用于实现文件系统、图形界面组件、组织结构管理、菜单系统等场景，特别是当需要表示“部分-整体”层次结构并统一处理单个对象和组合对象时。通过组合模式，可以构建灵活的树形结构，使代码更加简洁和可维护。
在这里插入图片描述