【设计模式】结构型-组合模式

前言

在软件开发中，设计模式是一种被广泛应用的解决问题的方法论。其中，结构性设计模式是一类特别重要的模式，它们用于处理类或对象之间的组合关系，其中之一就是组合模式。组合模式允许客户端统一对待单个对象和对象的组合，从而简化了代码的复杂性，增强了代码的灵活性和可维护性。

一、处理树形结构的挑战

场景假设：我们需要开发一个文件系统。它包含文件和文件夹，文件夹中又可以包含其他文件或文件夹。

// 文件类
class File {
    String name;
    
    File(String name) {
        this.name = name;
    }
    
    void display() {
        System.out.println("File: " + name);
    }
}

// 文件夹类，可以包含文件和其他文件夹
class Folder {
    String name;
    List<File> files;
    List<Folder> folders;
    
    Folder(String name) {
        this.name = name;
        this.files = new ArrayList<>();
        this.folders = new ArrayList<>();
    }
    
    void addFile(File file) {
        files.add(file);
    }
    
    void addFolder(Folder folder) {
        folders.add(folder);
    }
    
    void displayContents() {
        System.out.println("Folder: " + name);
        for (File file : files) {
            file.display();
        }
        for (Folder folder : folders) {
            folder.displayContents();
        }
    }
}

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.addFile(file1);
        folder2.addFile(file2);
        folder2.addFolder(folder1);
        
        // 显示文件夹 2 的内容，它包含文件夹 1 和文件 2
        folder2.displayContents();
        
        // 这个设计不利于扩展，如果我们想要添加新类型的文件系统元素，比如链接，我们需要修改 Folder 类
        // 这违反了开闭原则，并且使得代码难以维护和扩展
    }
}

上面的示例中，我们创建了两个类：File 和 Folder。File 类代表文件系统中的文件，而 Folder 类代表可以包含文件和其他文件夹的文件夹。这种设计的问题在于它不够灵活，难以扩展。例如，如果我们想要添加一个新的文件系统元素，如链接，我们需要修改 Folder 类来支持这种新类型的元素。这违反了开闭原则，即软件实体应该对扩展开放，对修改关闭。

除了上述问题，还存在以下问题：

代码重复：我们需要为文件和文件夹编写不同的处理代码，这导致了代码重复。
难以维护：如果文件系统的结构发生变化，比如添加新类型的元素，我们需要修改现有的代码，这使得维护变得困难。
扩展性差：当前的设计不允许灵活地添加新类型的文件系统元素，限制了系统的扩展性。

二、组合模式

组合模式是一种结构型设计模式，旨在将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式用于将对象组织成树形结构，以表示“部分-整体”的层次关系，使得客户端可以统一处理单个对象和对象的组合。

在组合模式中，有两种主要类型的对象：

叶子节点（Leaf）：表示树中的最终节点，它没有子节点。
复合节点（Composite）：表示树中的分支节点，它可以包含其他子节点，即可以是叶子节点，也可以是复合节点。

三、组合模式的核心组成

组合模式由三个关键角色组成：

组件（Component）：是组合中所有对象的共同接口，客户端通过这个接口操作组合中的对象。
叶子（Leaf）：表示树中的叶子节点，它实现了组件接口。
复合（Composite）：表示树中的复合节点，它实现了组件接口，并拥有子组件。

在这里插入图片描述

这里，Component 是抽象基类，定义了操作、添加子节点、删除子节点以及获取子节点的抽象方法。Leaf 类表示树结构中的叶子节点，它没有子节点。Composite 类表示树结构中的复合节点，它可以包含子节点，并且实现了对子节点的操作方法。

四、运用组合模式

场景假设：我们一个文件系统，其中包含文件和文件夹。这个文件系统需要能够以统一的方式处理单个文件和包含多个文件或子文件夹的文件夹。

定义抽象构件（Component）：首先，我们创建一个抽象类或接口 FileSystemComponent，它包含了管理子部件的公共接口，如添加（add）、删除（remove）和显示结构（displayStructure）子部件。

// 抽象构件：定义了文件系统中所有对象共有的接口
public abstract class FileSystemComponent {
    protected String name;
    // 子部件列表，用于存储文件或文件夹
    protected List<FileSystemComponent> children;

    // 构造函数初始化文件系统组件的名称
    public FileSystemComponent(String name) {
        this.name = name;
        this.children = new ArrayList<>();
    }

    // 添加子部件的方法
    public abstract void add(FileSystemComponent component);
    // 移除子部件的方法
    public abstract void remove(FileSystemComponent component);
    // 显示结构的方法，用于输出组件结构
    public abstract void displayStructure();
}

创建叶子构件（Leaf）：然后，我们实现 FileSystemComponent 接口来创建 File 类，这是树形结构中的末端对象，没有子部件。

// 叶子构件：实现了抽象构件的操作，代表没有子部件的文件
public class File extends FileSystemComponent {
    // 文件构造函数
    public File(String name) {
        super(name);
    }

    // 文件不支持添加操作，因此抛出异常
    @Override
    public void add(FileSystemComponent component) {
        throw new UnsupportedOperationException("Cannot add to a file.");
    }

    // 文件不支持移除操作，因此抛出异常
    @Override
    public void remove(FileSystemComponent component) {
        throw new UnsupportedOperationException("Cannot remove from a file.");
    }

    // 显示文件名称
    @Override
    public void displayStructure() {
        System.out.println("File: " + name);
    }
}

创建容器构件（Composite）：接下来，我们创建 Folder 类，它也是 FileSystemComponent 的实现，可以包含叶子构件或其他容器构件。

// 容器构件：可以包含叶子构件或其他容器构件的文件夹
public class Folder extends FileSystemComponent {
    // 文件夹构造函数
    public Folder(String name) {
        super(name);
    }

    // 添加子部件到文件夹
    @Override
    public void add(FileSystemComponent component) {
        children.add(component);
    }

    // 从文件夹移除子部件
    @Override
    public void remove(FileSystemComponent component) {
        children.remove(component);
    }

    // 显示文件夹及其子部件的结构
    @Override
    public void displayStructure() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : children) {
            component.displayStructure();
        }
    }
}

客户端使用：最后，客户端代码可以统一对待单个对象和组合对象，使得用户对单个对象和组合对象的使用具有一致性。

// 客户端使用示例
public class FileSystemClient {
    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.add(file1);
        folder2.add(file2);
        folder2.add(folder1);

        // 显示文件夹 2 的内容，它包含文件夹 1 和文件 2
        folder2.displayStructure();
    }
}

通过上述的组合模式，我们可以实现：

统一接口：File 和 Folder 都实现了 FileSystemComponent 接口，这意味着客户端代码可以以相同的方式处理它们。
递归结构：Folder 可以包含其他 Folder 对象，这允许我们创建一个递归的树形结构，反映了文件系统的真实层次结构。
易于扩展：如果我们想要添加新类型的文件系统元素，我们只需要创建一个新的类，继承自 FileSystemComponent，并实现必要的方法。我们不需要修改现有的 Folder 类。

五、组合模式的应用场景

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

图形用户界面（GUI）库： GUI 库通常使用组合模式来构建用户界面元素的层次结构。例如，窗口、面板、按钮和文本框可以作为容器对象，而文本、图像和复选框等用户界面元素可以作为叶子对象。
文件系统： 文件系统中的文件和目录可以被组织成一个树形结构。组合模式可以用于表示文件系统中的文件和目录，并且允许对它们进行统一的操作，如复制、移动和删除等。
组织架构： 组织架构中的部门、小组和员工等可以被组织成一个层次结构。组合模式可以用于表示组织架构，并且允许对不同层次的组织单元进行统一的管理。
菜单系统： 菜单系统通常具有多层次的菜单结构，例如菜单、子菜单和菜单项等。组合模式可以用于构建菜单系统，并且允许对菜单项和子菜单等组件进行统一的操作。
文件解析：在文件解析过程中，如 XML 文件、JSON 文件等，组合模式可以用来处理这些不同类型的文件，将它们表示为统一的对象，并提供一致的方法来读取和操作文件的内容。
电子设备： 电子设备通常具有复杂的层次结构，例如计算机系统中的硬件组件和软件模块等。组合模式可以用于表示这些层次结构，并且允许对不同层次的组件进行统一的控制和管理。