23种设计模式-组合(Composite)设计模式

news2025/4/22 9:07:51

组合设计模式

🚩什么是组合设计模式？
🚩组合设计模式的特点
🚩组合设计模式的结构
🚩组合设计模式的优缺点
🚩组合设计模式的Java实现
🚩代码总结
🚩总结

🚩什么是组合设计模式？

组合设计模式（Composite Pattern） 是一种 结构型设计模式，它允许你将对象组合成 树形结构 以表示 部分-整体 的层次结构。组合模式使得客户端可以 统一处理单个对象和组合对象，无需关心它们的具体类型。

使用场景

当需要表示 部分-整体 的层次结构时，例如 文件系统、菜单、组织结构 等。
当希望客户端能够 统一处理单个对象和组合对象 时。
当需要 递归地处理树形结构 时。

🚩组合设计模式的特点

统一性：组合模式使得客户端可以统一处理单个对象和组合对象。
递归性：组合模式支持递归地处理树形结构。
灵活性：可以动态地添加或删除组合对象中的子对象。
透明性：客户端无需知道处理的是单个对象还是组合对象。

🚩组合设计模式的结构

组合模式主要包含以下部分：

Component（抽象组件）：定义所有组件的通用接口，包括 叶子节点 和 容器节点。
Leaf（叶子节点）：表示树形结构中的叶子节点，没有子节点，类似于文件。
Composite（容器节点）：表示树形结构中的容器节点，可以包含子节点，类似于文件夹。
Client（客户端）：通过 Component 接口操作组合对象。

图例：

在这里插入图片描述

🚩组合设计模式的优缺点

✅ 优点

统一性：客户端可以统一处理单个对象和组合对象。
灵活性：可以动态地添加或删除组合对象中的子对象。
递归性：支持递归地处理树形结构。
透明性：客户端无需知道处理的是单个对象还是组合对象。

❌ 缺点

设计复杂性：组合模式的设计可能较为复杂，尤其是处理递归结构时。
性能问题：在处理深层嵌套的树形结构时，可能会影响性能。

🚩组合设计模式的Java实现

代码地址：GitHub

创建 抽象组件 AbstractFile，定义所有组件的通用接口。

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName AbstractFile
 * @Description 抽象组件,定义所有组件的通用接口
 * @date 2025/3/24 14:49
 **/
public abstract class AbstractFile {

    protected String name;

    public void printName() {
        System.out.println(name);
    }

    public abstract boolean Add(AbstractFile file);

    public abstract boolean Remove(AbstractFile file);

    public abstract List<AbstractFile> getChildren();
}

创建 叶子节点 File，表示树形结构中的叶子节点，类比文件系统中的文件。

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName File
 * @Description 创建 叶子节点 File，表示树形结构中的叶子节点
 * @date 2025/3/24 14:50
 **/
public class File extends AbstractFile {

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

    @Override
    public boolean Add(AbstractFile file) {
        return false;
    }

    @Override
    public boolean Remove(AbstractFile file) {
        return false;
    }

    @Override
    public List<AbstractFile> getChildren() {
        return null;
    }
}

创建 容器节点 Folder，表示树形结构中的容器节点，类比文件系统中的文件夹。

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName Folder
 * @Description 创建 容器节点 Folder，表示树形结构中的容器节点
 * @date 2025/3/24 14:51
 **/
public class Folder extends AbstractFile {

    private List<AbstractFile> childrenList = new ArrayList<AbstractFile>();

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

    @Override
    public boolean Add(AbstractFile file) {
        return childrenList.add(file);
    }

    @Override
    public boolean Remove(AbstractFile file) {
        return childrenList.remove(file);
    }

    @Override
    public List<AbstractFile> getChildren() {
        return childrenList;
    }
}

测试组合模式

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName CompositePattern
 * @Description 测试组合模式
 * @date 2025/3/24 14:53
 **/
public class CompositePattern {

    public static void main(String[] args) {
        AbstractFile root = new Folder("root");

        AbstractFile folderA = new Folder("folderA");
        AbstractFile folderB = new Folder("folderB");

        AbstractFile  fileC = new File("fileC");
        AbstractFile  fileD = new File("fileD");
        AbstractFile  fileE = new File("fileE");

        root.Add(folderA);
        root.Add(folderB);
        root.Add(fileC);

        folderA.Add(fileD);
        folderA.Add(fileE);

        print(root);
    }

    public static void print(AbstractFile file) {
        file.printName();

        List<AbstractFile> childrenList = file.getChildren();
        if (childrenList == null) return;

        for (AbstractFile children : childrenList) {
            print(children);
        }
    }
}