设计模式：Composite--组合模式-树形结构

已于 2023-01-11 15:38:49 修改
阅读量546 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
于 2019-05-22 09:06:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yubin1285570923/article/details/90277942
版权

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便，看看关系图：

透明方式：

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。

安全方式：

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。

 

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

代码实现：文件夹和文件例子，根节点加入文件和文件夹，文件夹里面再加文件等，然后递归显示名字

/**
 * 节点抽象
 */
public interface IFile {
    //获取显示文件夹或文件的父类
    public void display();

    //添加子节点
    public boolean add(IFile iFile);

    //移除
    public boolean remove(IFile iFile);

    public List<IFile> getChild();
}

*********************************************************************

/**
 * 文件夹
 */
public class Folde implements IFile {

    private String name;
    private List<IFile>  childrens;

    public Folde(String name) {
        this.name = name;
        childrens = new ArrayList<>();
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public boolean add(IFile iFile) {
        return childrens.add(iFile);
    }

    @Override
    public boolean remove(IFile iFile) {
        return childrens.remove(iFile);
    }

    @Override
    public List<IFile> getChild() {
        return childrens;
    }
}

*********************************************************************
package com.atguigu.composite;

import java.util.List;

/**
 * 文件
 */

public class File  implements IFile {
    private String name;

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

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public boolean add(IFile iFile) {
        return false;
    }

    @Override
    public boolean remove(IFile iFile) {
        return false;
    }

    @Override
    public List<IFile> getChild() {
        return null;
    }
}



*********************************************************************
package com.atguigu.composite;


import org.springframework.util.CollectionUtils;

import java.util.List;

public class MailClass {
    public static void main(String[] args) {
        //c盘
        Folde root = new Folde("C");
        //beifeng目录
        Folde beifengFolde = new Folde("beifeng");
        //beifeng.txt文件
        File file = new File("beifeng.txt");

        root.add(beifengFolde);
        root.add(file);

        Folde ibeifengFolde = new Folde("ibeifeng");
        beifengFolde.add(ibeifengFolde);
        File ifile = new File("ibeifeng.txt");
        ibeifengFolde.add(ifile);
        displayTree(root,0);
    }


    public static void displayTree(IFile iFile,int deep){
        for(int i = 0; i < deep; i++) {
            System.out.print("--");
        }

        //显示自己的名称
        iFile.display();
        //获取子树
        List<IFile> child = iFile.getChild();
        if(!CollectionUtils.isEmpty(child)) {
            for(int i = 0; i < child.size(); i++) {
                IFile ifile = child.get(i);
                if(ifile instanceof File) {
                    for(int j = 0; i < deep; i++) {
                        System.out.print("--");
                    }
                    ifile.display();
                }else {
                    displayTree(ifile,deep+1);
                }
            }
        }

    }
}

 测试结果：

二、事例

case1

/**
 * @auhtor
 * @create 2023-01-11-11:18
 * 安全方式
 */
public abstract class Component {
    protected String name;

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

    public String getName() {
        return name;
    }

    public Component setName(String name) {
        this.name = name;
        return this;
    }
    public abstract void display();
}

// 非叶子节点
public class Composite extends Component {

    private List<Component> child = new ArrayList<>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void display() {
        System.out.println(getName());
        if (child != null && child.size() > 0) {
            for (Component component : child) {
                component.display();
            }
        }
    }

    public boolean addChild(Component component) {
        child.add(component);
        return true;
    }

    public boolean removeChild(Component component) {
        child.remove(component);
        return true;
    }

    public Component getChild(int index) {
        return child.get(index);
    }

}

// 叶子节点
public class Leaf extends Component{
    public Leaf(String name) {
        super(name);
    }

    @Override
    public void display() {
        System.out.println(getName());
    }

}

输出

public static void main(String[] args) {
        // component 抽象类定义基本方法，非叶子节点composite定义各特有方法， leaf叶子节点定义自己方法
        Composite driveD = new Composite("D盘");

        Composite doc = new Composite("文档");
        doc.addChild(new Leaf("简历.doc"));
        doc.addChild(new Leaf("项目介绍.ppt"));

        driveD.addChild(doc);

        Composite misic = new Composite("音乐");
        Composite jay = new Composite("周杰伦");
        jay.addChild(new Leaf("双截棍.mp3"));
        jay.addChild(new Leaf("告白气球.mp3"));

        Composite jack = new Composite("张学友");
        jack.addChild(new Leaf("吻别.mp3"));
        jack.addChild(new Leaf("一千个伤心的理由..mp3"));

        misic.addChild(jay);
        misic.addChild(jack);

        driveD.addChild(misic);

        driveD.display();

    }

// console
D盘
文档
简历.doc
项目介绍.ppt
音乐
周杰伦
双截棍.mp3
告白气球.mp3
张学友
吻别.mp3
一千个伤心的理由..mp3

case2

/**
 * @auhtor
 * @create 2023-01-11-9:50
 *
 *  透明方式
 */
public abstract class Node {
    protected String name;

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

    public String getName() {
        return name;
    }

    public Node setName(String name) {
        this.name = name;
        return this;
    }

    public void add(Node node) throws Exception {
        throw new RuntimeException("不可添加");
    }

    public abstract void display();
}

// 非叶子节点
public class Folder extends Node{

    private List<Node> child = new ArrayList<>();

    public Folder(String name) {
        super(name);
    }

    @Override
    public void add(Node node) throws Exception {
        child.add(node);
    }

    @Override
    public void display() {
        System.out.println(this.name);
        if (child != null && child.size() > 0) {
            for (Node node : child) {
                node.display();
            }
        }
    }
}

// 叶子节点
public class Leaf extends Node {

    public Leaf(String name) {
        super(name);
    }

    @Override
    public void display() {
        System.out.println(this.name);
    }
}

输出

public class MainClient {

    public static void main(String[] args) {
        // 组合模式 leaf 叶子节点  composite 非叶子节点
        Node node = new Folder("F:\\yubin\\sql_script\\20220408\\contractmg");
        try {
            createTree(node);
        } catch (Exception e) {
            e.printStackTrace();
        }
        node.display();
    }


    public static void createTree(Node node) throws Exception {
        File file = new File(node.getName());
        // 找出这个目录下面所有的文件和文件夹
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()) {
                Leaf leaf = new Leaf(file1.getAbsolutePath());
                node.add(leaf);
            }
            if (file1.isDirectory()) {
                Folder folder = new Folder(file1.getAbsolutePath());
                node.add(folder);
                createTree(folder);
            }
            
        }
    }
}

// console
F:\yubin\sql_script\20220408\contractmg
F:\yubin\sql_script\20220408\contractmg\20220414合同脚本.rar
F:\yubin\sql_script\20220408\contractmg\准生产
F:\yubin\sql_script\20220408\contractmg\准生产\contract.sql
F:\yubin\sql_script\20220408\contractmg\准生产\dic-service.sql
F:\yubin\sql_script\20220408\contractmg\生产
F:\yubin\sql_script\20220408\contractmg\生产\contract.sql
F:\yubin\sql_script\20220408\contractmg\生产\dic-service.sql

case3

// 抽象层，接口或者抽象类
public abstract class OrganizationComponent {

    protected String name;

    protected String desc;

    public String getDesc() {
        return desc;
    }

    public OrganizationComponent setDesc(String desc) {
        this.desc = desc;
        return this;
    }

    public OrganizationComponent(String name, String desc) {

        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public OrganizationComponent setName(String name) {
        this.name = name;
        return this;
    }

    public void add(OrganizationComponent o) throws Exception{
        throw new RuntimeException("无法添加");
    }

    public void remove(OrganizationComponent o) throws Exception{
        throw new RuntimeException("无法删除");
    }

    public abstract void display(int deep);
}

// 非叶子节点 大学
public class University extends OrganizationComponent {
    private List<OrganizationComponent> child = new ArrayList<>();

    public University(String name, String desc) {
        super(name, desc);
    }

    @Override
    public void add(OrganizationComponent o) throws Exception {
        child.add(o);
    }

    @Override
    public void remove(OrganizationComponent o) throws Exception {
        child.remove(o);
    }

    @Override
    public void display(int deep) {
        String str = "";
        for (int i = 0; i < deep; i++) {
            str += "-";
        }
        System.out.println(str + getName() + ":" + getDesc());
        if (child != null && child.size() > 0) {
            for (OrganizationComponent component : child) {
                component.display(deep + 4);
            }
        }

    }
}


// 非叶子节点，学院
public class College extends OrganizationComponent {
    private List<OrganizationComponent> child = new ArrayList<>();

    public College(String name, String desc) {
        super(name, desc);
    }

    @Override
    public void add(OrganizationComponent o) throws Exception {
        child.add(o);
    }

    @Override
    public void remove(OrganizationComponent o) throws Exception {
        child.remove(o);
    }

    @Override
    public void display(int deep) {
        String str = "";
        for (int i = 0; i < deep; i++) {
            str += "-";
        }
        System.out.println(str + getName() + ":" + getDesc());
        if (child != null && child.size() > 0) {
            for (OrganizationComponent component : child) {
                component.display(deep + 4);
            }
        }
    }
}

// 叶子节点，专业
public class Department extends OrganizationComponent {

    public Department(String name, String desc) {
        super(name, desc);
    }

    @Override
    public void display(int deep) {
        String str = "";
        for (int i = 0; i < deep; i++) {
            str += "-";
        }
        System.out.println(str + getName() + ":" + getDesc());
    }
}

输出

public class MainClient {
    public static void main(String[] args) throws Exception{
        University university = new University("清华大学","国内顶级大学");
        College college = new College("计算机学院","计算机学院");
        Department department = new Department("软件工程","软件工程不错");
        Department department2 = new Department("网络工程","网络工程");
        Department department3 = new Department("计算机科学与技术","计算机科学与技术是老牌专业");
        college.add(department);
        college.add(department2);
        college.add(department3);

        College college2 = new College("通信工程","通信工程不错");
        Department department4 = new Department("信息工程","信息工程哈可以");
        Department department5 = new Department("通信工程","通信工程值得学习");
        college2.add(department4);
        college2.add(department5);

        university.add(college);
        university.add(college2);

        university.display(0);
    }
}

// console
清华大学:国内顶级大学
----计算机学院:计算机学院
--------软件工程:软件工程不错
--------网络工程:网络工程
--------计算机科学与技术:计算机科学与技术是老牌专业
----通信工程:通信工程不错
--------信息工程:信息工程哈可以
--------通信工程:通信工程值得学习

yubin1285570923
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
设计模式，组合模式，c++实现，树形结构的设计模式
ganfanren00001的博客
10-16 310
组合模式：用来描述部分与整体的关系，定义为：将对象组合成树形结构来表示“部分－整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。 类图摘自设计模式之禅： 抽象角色：组合对象的共有方法和属性。 叶子：最小单位，无分支 树枝：组合树枝和叶子形成树结构，常有容器和增删查函数。 优点： 高层模块调用简单（垂直管理），所有节点均是抽象角色，局部和整体对调用者来说没有区别， 高层不用管自己处理的是单个还是整体，简化了高层模块的代码。 节点水平自由增加，只要找到它的父节点就可，但不好垂直增加。 缺点： 有一
设计模式-结构型-组合模式
Andy的博客
10-24 137
定义 组合模式，又叫部分-整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。 ps://www.jianshu.com/p/8ec55296dd9c ...
设计模式--组合Composite--树状结构专用模式
qq_lindy的博客
07-01 91
图解 代码 package com.qqlindy.composite; import java.util.ArrayList; import java.util.List; abstract class Node { abstract public void p(); } class LeafNode extends Node{ String content; ...
设计模式（十一）——树形结构：组合模式
布衣大侠的博客
11-25 1176
组合模式 组合模式（Composite Pattern）,又称之为部分整体模式。将对象组合成树形结果以表示“部分-整体”的层次结果。组合模式使得用户对单个对象的组合对象具有一致性。当需求中国是提现部分与整体层次的结构是，以及希望用户可以忽略组合对象与单个对象的不同，统一的使用组合结构中的所有对象时，就应该考虑组合模式了。 ...
可以实现树形结构的设计模式（组合模式）
weixin_44198475的博客
06-28 1911
组合模式 1.基本介绍 组合模式（Composite Pattern）,又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系 组合模式依据树形结构来组合对象，用来表示部分以及整体层次，属于结构性模式 组合模式使得用户对单个对象和组合对象的访问具有一致性（组合模式能让用户以一致的方式处理个别对象以及组合对象） 2.原理类图 Component：这是组合中对象的声明接口或者抽象类，在适当情况下，实现所有类共有的接口默认行为，用于访问和管理Component的子部
java常用设计模式-组合模式
08-26
组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得客户端可以统一对待单个对象和对象组合。在组合模式中，有两种基本类型的对象：叶...
.NET设计模式（11）：组合模式（CompositePattern）
03-01
[GOF《设计模式》]图1Composite模式结构图组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。让用户一致地使用单个对象和组合对象。虽然例子抽象一些，但是算术表达式确实是组合的例子。算术表达式包括操作...
C# 设计模式系列教程-组合模式
01-20
　将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 2. 解决的问题 　当希望忽略单个对象和组合对象的区别，统一使用组合结构中的所有对象（将这种...
C++设计模式之组合模式
01-20
在GOF的《设计模式:可复用面向对象软件的基础》一书中对组合模式是这样说的：将对象组合成树形结构以表示“部分-整体”的层次结构。组合（Composite）模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式...
组合模式----树形结构
LuckXinXin的博客
10-14 161
定义：就是用小的子对象来构建更大的对象，而这些小的子对象本身也也许是由更小的对象构成 特点：可以用树形方式创建对象的结构；把相同的操作应用在组合对象和单个对象上（相同的API） 使用场景： 1）表示对象的部分-整体层次结构。只需要通过请求树中的最顶层对象，便能对树做统一的操作 2）客户希望统一对待树中的所有对象。忽略组合对象和叶对象的区别，他们会各自做自己的事情 文件扫描，适合使用组合模式，路径是...
组合模式二叉树，前序、中序、后续，迭代器模式访问遍历
06-28
使用composite模式构成二叉树，并用迭代器模式封装访问，前序、中序和后序的遍历。JAVA 编写。 Main中直接运行
【设计模式】组合模式？建议改名叫树形模式！
程序员徐小白的博客
10-24 243
什么是组合模式（Composite） 概念 组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。 组合模式关注的是对象间的结构，希望能够让调用者在使用一组对象时和使用单个对象没什么区别，屏蔽掉组合对象和单个对象的差别。 个人感觉组合模式应该叫做树形模式，当对象呈现成树形结构时，使用这个模式就非常的好了，建议改名。 组合模式分为两种
组合模式解决树状结构
不忘初心
10-14 1058
问题介绍 前几天客户提出了一个很诡异的需求，能不能把留言做成任何人都可以对其他人的留言再次留言评论。当时我就想A评B，C评A，D评B。。。好吧。我脑子不够用了。 分析过程
组合模式Composite——树形结构不再头疼
04-25 307
组合模式可以在需要针对“树形结构”进行操作的应用中使用，例如扫描文件夹、渲染网站导航结构等等。 一、什么是组合模式？ 组合模式将一组相似的对象看做一个对象处理，并根据一个树状结构来组合对象，提供一个统一的方法去访问相应的对象，使得用户对单个对象和组合对象的使用具有一致性。 很抽象对吧，那就到了举例子的时候： 公司组织关系树 公司组织关系可能分为部门与人，其中人属于部门，有的人有下属，有的人没有下属。如果我们统一将部门、人抽象为组织节点，就可以方便的统计某个部门下有多少人、财务数据等等，
【学习设计模式11】树形处理——组合模式
Aiky哇
06-07 196
上篇： 【学习设计模式10】分离抽象与实现——桥接模式_Aiky哇的博客-CSDN博客上篇：【学习设计模式9】兼容扩展坞—适配器模式_Aiky哇的博客-CSDN博客上篇：【学习设计模式8】组装流水线——建造者模式_Aiky哇的博客-CSDN博客上篇：【学习设计模式7】复制粘贴就得了——原型模式_Aiky哇的博客-CSDN博客那么有没有一种方法可以名正言顺的复制粘贴呢？当然有了，那就是原型模式。原型模式也叫克隆模式。https://aikysay.blog.csdn.net/article/deta....
设计模式之组合模式-树形结构的处理
zhulongxi的博客
09-25 5856
一、描述：      对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员对象（可以是容器对象，也可以是叶子对象）并调用执行，牵一而动百，其中使用了递归调用的机制来对整个结构进行处理。由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多数情况下我们希望一致地处理它们，因为对于这些对象的区别对
Composite pattern和树
点缀星辰
06-10 93
一切从，那一段代码开始的      开始我们考虑这样一个问题，就是假定我们要写一个方法来遍历一个目录里所有的文件。因为目录里面可能还含有子目录，我们可能就需要用到循环，递归等这样的思路。一个典型的思路如下： 1. 首先列出该文件夹里所有内容。 2. 遍历里面所有的元素，如果该元素为纯文件，则显示文件名；否则，则递归调用该函数。 按照以上的思路，可以写出如下的一段简单的代码：   voi...
组合模式就是几个模式组合一起吗?来看看组合模式原理
09-09 466
组合模式引导篇及组合模式原理 在上一个《迭代器模式》中，我们讲到了阿里收购网易考拉后，店铺合并的问题使用到了迭代器模式。现在又有了新需求。我们先来看看新需求： 先说明：组合模式并非是把之前学过的设计模式组合在一起的一种模式哈。别理解错了。 来源：凯哥Java(kaigejava) 在原有菜单的基础上，新增餐后甜点功能，如在中餐厅(DinerMenu)中添加餐后甜点。 我们先来回...
设计模式（九）——组合模式
qq_42765068的博客
07-12 112
一、组合模式介绍 组合模式基本介绍 1）组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示（“整体-部分”）的层次关系； 2）组合模式依据树形结构来组合对象，用来表示部分以及整体层次； 3）这种类型的设计模式属于结构型模式； 4）组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的处理方式处理个别对象以及组合对象。 组合模式的原理类图 对原理结构图的说明-即（组合模式的角色及职责） Component：这是组合
设计模式原理与应用之结构型模式.pptx
最新发布
09-28
设计模式原理与应用

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值