八、结构型（组合模式）

🕗 发布于 2024-10-14 09:47 组合模式

组合模式

概念
组合模式（Composite Pattern）是一种结构型设计模式，允许你将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端可以统一对待单个对象和组合对象。

应用场景

树形结构表示：适用于需要以树形结构表示对象层次的场景，例如文件系统、组织结构图、UI组件树等。
处理部分和整体的一致性：在需要统一处理单个对象和组合对象的情况下，组合模式可以简化客户端代码，因为客户端无需关心处理的对象是单个还是组合对象。
递归操作：适用于需要对树形结构中的所有节点进行递归操作的场景，例如遍历整个树形结构、计算总值、查找等。

注意点

透明性与安全性权衡：组合模式有两种实现方式，透明组合和安全组合。透明组合允许所有组件具有相同接口，操作更统一，但会有不适用的操作（如对叶子节点调用添加子节点的操作）。安全组合则为叶子和组合节点提供不同接口，但操作灵活性降低。
性能问题：由于组合模式需要递归地处理整个树形结构，因此在大规模树形结构中可能存在性能问题。
节点间的职责分配：确保合理分配叶子节点和组合节点的职责，避免职责不明确。

核心要素

Component（抽象构件）：定义叶子节点和组合节点的共同接口。
Leaf（叶子节点）：表示树形结构的基本元素，不包含子节点。
Composite（组合节点）：表示有子节点的复杂元素，包含添加、删除和遍历子节点的功能。
统一处理：客户端可以统一处理单个对象和组合对象。

Java代码完整示例

// 抽象构件
interface Component {
    void operation();
}

// 叶子节点
class Leaf implements Component {
    private String name;

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

    @Override
    public void operation() {
        System.out.println("叶子 " + name + " 被访问");
    }
}

// 组合节点
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
        children.add(component);
    }

    public void remove(Component component) {
        children.remove(component);
    }

    public Component getChild(int i) {
        return children.get(i);
    }

    @Override
    public void operation() {
        System.out.println("组合节点被访问");
        for (Component child : children) {
            child.operation();
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建叶子节点
        Leaf leaf1 = new Leaf("1");
        Leaf leaf2 = new Leaf("2");
        Leaf leaf3 = new Leaf("3");

        // 创建组合节点
        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);

        Composite root = new Composite();
        root.add(composite);
        root.add(leaf3);

        // 统一调用组合结构
        root.operation();
    }
}

输出：

组合节点被访问
组合节点被访问
叶子 1 被访问
叶子 2 被访问
叶子 3 被访问

各种变形用法完整示例

透明组合模式
在这种实现方式中，叶子和组合节点共享相同的接口，客户端可以透明地使用组合和叶子对象。

代码示例：

// 抽象构件（透明组合）
interface Component {
    void operation();
    void add(Component component);
    void remove(Component component);
    Component getChild(int i);
}

// 叶子节点（透明组合）
class Leaf implements Component {
    private String name;

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

    @Override
    public void operation() {
        System.out.println("叶子 " + name + " 被访问");
    }

    @Override
    public void add(Component component) {
        throw new UnsupportedOperationException("叶子节点不支持添加操作");
    }

    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException("叶子节点不支持删除操作");
    }

    @Override
    public Component getChild(int i) {
        throw new UnsupportedOperationException("叶子节点没有子节点");
    }
}

// 组合节点（透明组合）
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    @Override
    public void operation() {
        System.out.println("组合节点被访问");
        for (Component child : children) {
            child.operation();
        }
    }

    @Override
    public void add(Component component) {
        children.add(component);
    }

    @Override
    public void remove(Component component) {
        children.remove(component);
    }

    @Override
    public Component getChild(int i) {
        return children.get(i);
    }
}

// 客户端
public class ClientTransparentComposite {
    public static void main(String[] args) {
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");

        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);

        Composite root = new Composite();
        root.add(composite);
        root.add(leaf3);

        root.operation();
    }
}

安全组合模式
在安全组合模式下，叶子节点和组合节点有各自不同的接口，避免了客户端对叶子节点调用不适用的操作。

代码示例：

// 抽象构件
interface Component {
    void operation();
}

// 叶子节点（安全组合）
class Leaf implements Component {
    private String name;

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

    @Override
    public void operation() {
        System.out.println("叶子 " + name + " 被访问");
    }
}

// 组合节点（安全组合）
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
        children.add(component);
    }

    public void remove(Component component) {
        children.remove(component);
    }

    public Component getChild(int i) {
        return children.get(i);
    }

    @Override
    public void operation() {
        System.out.println("组合节点被访问");
        for (Component child : children) {
            child.operation();
        }
    }
}

// 客户端
public class ClientSafeComposite {
    public static void main(String[] args) {
        Leaf leaf1 = new Leaf("1");
        Leaf leaf2 = new Leaf("2");
        Leaf leaf3 = new Leaf("3");

        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);

        Composite root = new Composite();
        root.add(composite);
        root.add(leaf3);

        root.operation();
    }
}

组合模式与职责链模式结合
组合模式与职责链模式可以结合使用，使得组合结构的每个节点都有机会处理请求。

代码示例：

// 抽象构件
interface Component {
    void operation();
    void setNext(Component next);
}

// 叶子节点（与职责链模式结合）
class Leaf implements Component {
    private String name;
    private Component next;

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

    @Override
    public void operation() {
        System.out.println("叶子 " + name + " 被访问");
        if (next != null) {
            next.operation();
        }
    }

    @Override
    public void setNext(Component next) {
        this.next = next;
    }
}

// 组合节点
class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    private Component next;

    public void add(Component component) {
        children.add(component);
    }

    @Override
    public void operation() {
        System.out.println("组合节点被访问");
        for (Component child : children) {
            child.operation();
        }
        if (next != null) {
            next.operation();
        }
    }

    @Override
    public void setNext(Component next) {
        this.next = next;
    }
}

// 客户端
public class ClientChainComposite {
    public static void main(String[] args) {
        Leaf leaf1 = new Leaf("1");
        Leaf leaf2 = new Leaf("2");

        Composite composite = new Composite();
        composite.add(leaf1);
        composite.add(leaf2);

        Leaf leaf3 = new Leaf("3");
        composite.setNext(leaf3);

        composite.operation();
    }
}

这些示例展示了组合模式的基本用法及其多种变形。

原文地址：https://blog.csdn.net/xiaoqi270620903/article/details/142872336

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：使用HTML、CSS和JavaScript创建图像缩放功能
下一篇：集合类HashMap,HashTable，ConcurrentHashMap区别?

Html乘法
【代码】Html乘法。
阅读更多2024-10-14
局域网内的rtmp直播软件
在局域网内最小的直播服务器和推流直播、播放三合一的软件，简单易用，一键完成
阅读更多2024-10-14
Leetcode 1203. 项目管理
有 n 个项目，每个项目或者不属于任何小组，或者属于 m 个小组之一。group[i] 表示第 i 个项目所属的小组，如果第 i 个项目不属于任何小组，则 group[i] 等于 -1。项目和小组都是
阅读更多2024-10-14
javaweb - 请求响应代码实现
中的required属性默认为true，代表该请求参数必须传递，如果不传递将报错。如果该参数是可以选的，可以将required属性设置为false。在原始的web程序中，获取请求参数，需要通过Http
阅读更多2024-10-14
Docker镜像制作实战实现淘宝网站部署
Docker镜像制作实战实现淘宝网站部署
阅读更多2024-10-14
开发实时美颜系统：视频美颜SDK与直播平台的集成方案详解
在视频直播过程中，实时处理视频流是核心步骤。开发者需要将采集到的视频流传递给视频美颜SDK进行处理，并在直播界面展示处理后的视频。一般来说，视频美颜SDK会提供回调函数，通过这些回调函数将处理过的视频
阅读更多2024-10-14
如何发布自己写的模块。应当怎么编写
这样可以在安装你的模块时，自动安装所需的依赖包。5. 检查依赖兼容性：在开发过程中，使用如 pipdeptree 这样的工具可以查看项目的依赖树，了解包之间的依赖关系，及时发现并解决版本冲突问题。7.
阅读更多2024-10-14
富士胶片人像汽车照片Lr调色教程，手机滤镜PS+Lightroom预设下载！
富士胶片人像汽车照片的调色旨在营造出独特的复古、文艺氛围。通过 Lightroom 的调色工具，将人像与汽车完美融合在具有富士胶片特色的画面中，展现出别样的美感。
阅读更多2024-10-14
js将文本添加到剪贴板上
剪贴板添加文本兼容写法。
阅读更多2024-10-14
SQL 自学：如何利用 SQL 的 INSERT 语句将数据插入表中
在 SQL 中，INSERT语句是用于向数据库表中添加新数据的关键操作。无论是创建新的记录还是批量导入数据，掌握INSERT语句的使用方法都是至关重要的。本文将详细介绍如何利用INSERT语句将数据插
阅读更多2024-10-14

八、结构型（组合模式）

组合模式

相关文章