设计模式（9）—— 组合模式

最新推荐文章于 2024-11-02 15:12:27 发布
最新推荐文章于 2024-11-02 15:12:27 发布
阅读量95 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 组合模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44287057/article/details/132273746
版权

组合模式一般用于树形结构的处理，比如文件系统中对文件的处理

1. 引出问题

需求：设计一个杀毒软件，该软件既可以对文件夹杀毒，也可以对单独的文件进行杀毒，同时可以为不同类型的文件（如图片或文档）提供不同的杀毒方式

在图中的树形目录结构中，可以分为文件夹和具体文件，文件夹内可以包含文件夹或文件，又称容器，而具体文件不会再包含任何其他文件，故又称为叶子

现在编写文件夹与具体文件的代码

图像文件类：

public class ImageFile {
    private String name;

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

    public void killVirus(){
        //模拟杀毒
        System.out.println("----对图像文件： " + name + "，进行杀毒");
    }
}

文本文件类：

public class TextFile {
    private String name;

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

    public void killVirus(){
        //模拟杀毒
        System.out.println("----对文本文件： " + name + "，进行杀毒");
    }
}

文件夹类：

public class Folder {
    private String name;
    private List<Folder> folderList = new ArrayList<>();
    private List<ImageFile> imageList = new ArrayList<>();
    private List<TextFile> textList = new ArrayList<>();

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

    public void addFolder(Folder folder){
        folderList.add(folder);
    }

    public void addImage(ImageFile image){
        imageList.add(image);
    }

    public void addText(TextFile text){
        textList.add(text);
    }

    //此处省略三个用于删除成员的remove方法

    //此处省略三个用于获取成员的get方法

    public void killVirus(){
        System.out.println("****对文件夹： " + name + "，进行杀毒");

        //对Folder类型的成员，调用Folder类的杀毒方法
        for (Folder folder : folderList) {
            folder.killVirus();
        }

        //对Image类型的成员，调用ImageFile类的杀毒方法
        for (ImageFile imageFile : imageList) {
            imageFile.killVirus();
        }

        //对Text类型的成员，调用TextFile类的杀毒方法
        for (TextFile textFile : textList) {
            textFile.killVirus();
        }
    }
}

编写客户端进行测试：

public class Client {
    public static void main(String[] args) {

        Folder folder1 = new Folder("Sunny的资料");
        Folder folder2 = new Folder("图像文件");
        Folder folder3 = new Folder("文本文件");

        ImageFile imageFile1 = new ImageFile("小龙女.jpg");
        ImageFile imageFile2 = new ImageFile("张无忌.gif");

        TextFile textFile1 = new TextFile("九阴真经.txt");
        TextFile textFile2 = new TextFile("葵花宝典.doc");

        folder2.addImage(imageFile1);
        folder2.addImage(imageFile2);

        folder3.addText(textFile1);
        folder3.addText(textFile2);

        folder1.addFolder(folder2);
        folder1.addFolder(folder3);

        folder1.killVirus();
    }
}

测试结果如下：

存在的问题：

  1. 文件夹类Folder内部较为复杂，既需要运用集合类存储各类的文件夹和文件，而且需要分别实现添加、删除、获取的方法，内部代码冗余情况较为严重
  2. 系统中没有提供抽象层，在客户端中需要具体的指定Folder、ImageFile、TextFile的类型，不具备通用性，无法进行统一处理
  3. 系统的可扩展性较差，如果新增一种文件格式如视频文件VideoFile，则需要对Folder类进行大量改动

2. 组合模式介绍

定义：组合多个对象形成树形结构以表示具有“部分—整体”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，又可以称为“部分—整体”（Part-Whole）模式

引入抽象构件类Component，所有容器和叶子类都是它的子类，客户端也针对它进行编程

组合模式中包含以下三种角色：

  1. Component（抽象构件）
  2. Leaf（叶子构件）
  3. Composite（容器构件）

3. 以组合模式重构案例

抽象构件：AbstractFile

public abstract class AbstractFile {
    public abstract void add(AbstractFile file);
    public abstract void remove(AbstractFile file);
    public abstract AbstractFile getChild(int i);
    public abstract void killVirus();
}

叶子构件1：ImageFile

public class ImageFile extends AbstractFile {

    private String name;

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

    @Override
    public void add(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public void remove(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public AbstractFile getChild(int i) {
        System.out.println("对不起，不支持此方法！");
        return null;
    }

    @Override
    public void killVirus() {
        //模拟杀毒
        System.out.println("----对图像文件： " + name + "，进行杀毒");
    }
}

叶子构件2：TextFile

public class TextFile extends AbstractFile {

    private String name;

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

    @Override
    public void add(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public void remove(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public AbstractFile getChild(int i) {
        System.out.println("对不起，不支持此方法！");
        return null;
    }

    @Override
    public void killVirus() {
        //模拟杀毒
        System.out.println("----对文本文件： " + name + "，进行杀毒");
    }
}

叶子构件3：VideoFile

public class VideoFile extends AbstractFile {

    private String name;

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

    @Override
    public void add(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public void remove(AbstractFile file) {
        System.out.println("对不起，不支持此方法！");
    }

    @Override
    public AbstractFile getChild(int i) {
        System.out.println("对不起，不支持此方法！");
        return null;
    }

    @Override
    public void killVirus() {
        //模拟杀毒
        System.out.println("----对视频文件： " + name + "，进行杀毒");
    }
}

容器构件：Folder

public class Folder extends AbstractFile {

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

    private String name;

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

    @Override
    public void add(AbstractFile file) {
        fileList.add(file);
    }

    @Override
    public void remove(AbstractFile file) {
        fileList.remove(file);
    }

    @Override
    public AbstractFile getChild(int i) {
        return fileList.get(i);
    }

    @Override
    public void killVirus() {
        //模拟杀毒
        System.out.println("****对文件夹： " + name + "， 进行杀毒");

        //递归对子文件进行处理
        for (AbstractFile file : fileList) {
            file.killVirus();
        }
    }
}

编写客户端测试类：Client

public class Client {
    public static void main(String[] args) {

        Folder folder1 = new Folder("Sunny的资料");
        Folder folder2 = new Folder("图像文件");
        Folder folder3 = new Folder("文本文件");
        Folder folder4 = new Folder("视频文件");

        ImageFile imageFile1 = new ImageFile("小龙女.jpg");
        ImageFile imageFile2 = new ImageFile("张无忌.gif");

        TextFile textFile1 = new TextFile("九阴真经.txt");
        TextFile textFile2 = new TextFile("葵花宝典.doc");

        VideoFile videoFile = new VideoFile("倚天屠龙记.avi");

        folder2.add(imageFile1);
        folder2.add(imageFile2);

        folder3.add(textFile1);
        folder3.add(textFile2);

        folder4.add(videoFile);

        folder1.add(folder2);
        folder1.add(folder3);
        folder1.add(folder4);

        //以folder1为入口，开始杀毒
        folder1.killVirus();
    }
}

测试结果如下：

4. 透明组合模式与安全组合模式

上一节使用组合模式对案例进行了重构，重构后的系统增强了程序的可扩展性，当需要新增文件类型时，只需要让新的文件类型类作为叶子构件继承抽象构件并实现方法即可

然而，现有的系统仍然存在一个问题：每次创建新的构件的时候，都要重复实现add、remove和get方法

4.1. 透明组合模式

将add等方法直接在AbstractFile中做默认实现

修改代码：

public abstract class AbstractFile {
    public void add(AbstractFile file){
        System.out.println("对不起，不支持该方法");
    }
    public void remove(AbstractFile file){
        System.out.println("对不起，不支持该方法");
    }
    public AbstractFile getChild(int i){
        System.out.println("对不起，不支持该方法");
        return null;
    }
    public abstract void killVirus();
}

修改之后，虽然叶子构件无需重复实现这几个方法，但是它们实际上仍然继承到了这几个它们并不需要用到的方法，客户端仍然可以调用抽象构件中的add等方法

4.2. 安全组合模式

在抽象构件中不声明add等方法，到容器构件中再创建方法

修改代码：

public abstract class AbstractFile {
    public abstract void killVirus();
}

修改之后，客户端如果通过抽象构件创建容器构件的话，无法调用在容器构件中实现的add、remove和get方法，即导致容器构件中新增的方法对客户端不可见，若要完整实现预期的功能，就不能够再通过抽象构件统一定义对象

Heton_325
关注
专栏目录
设计模式——组合模式
01-07
由于不同地区存在着上下级关系，且会拥有多平级组合，如果采用每个组合主一个类，这样需要创建的类特别多，此时可使用组合模式，如下图： 上图左边可转为右边的递归关系，其原理是把一组相似的对象当作一个单一的...
java设计模式之——组合模式(结构型模式 )
04-06
NULL 博文链接：https://lvwenwen.iteye.com/blog/1549415
设计模式 之 —— 组合模式
Jilit_jilit的博客
08-13 1192
设计模式之 —— 组合模式 含java代码示例，一篇文章即可看懂
前端开发设计模式——组合模式
jxnd123456的博客
10-08 2178
组合模式是一种结构型设计模式，它将对象组合成树形结构以表示 “部分 - 整体” 的关系。在前端开发中，这种模式允许将单个的 UI 元素（如按钮、文本框等叶节点）和由多个元素组成的复合元素（如包含多个子元素的面板等组合对象）以统一的方式进行处理。创建一个抽象类或接口，定义叶节点和组合对象共有的方法。// 抽象组件类// 抽象的操作方法，例如渲染render() {
23种设计模式——组合模式
万里顾一程的博客
11-18 853
文章目录23种设计模式——组合模式1、组合模式概述2、组合模式的结构3、组合模式的实现 23种设计模式——组合模式 1、组合模式概述 组合模式的定义 组合模式(Composite Pattern)，又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。 组合模式依据树形结构来组合对象，用来表示部分以及整体层次。 这种类型的设计模式属于结构型模式。 组合模式使得用户对单个对象和组合对象的访问具有一致性，即**：组合能让客户以一致的方式处理个别对象以及组合对象**。
Java设计模式系列——组合模式
猿来好吧的博客
03-23 621
文章目录1、什么是组合模式（Composite Pattern）2、组合模式详解2.1、组合模式解决的问题2.2、组合模式设计类图2.3、组合模式角色构成3、组合模式实现步骤3.1、定义抽象组件接口3.2、实现叶子节点3.3、定义实现组件集合类4、组合模式解决的问题 1、什么是组合模式（Composite Pattern） 组合模式是一种对象结构型模式，将对象组合成树形结果以表示“部分-整体”的层次结构。Composite使得用户对单个和组合对象的使用具有一致性。 以上是《设计模式》中文译版的一书中的定义，
设计模式——组合模式（附代码示例）
枫陵的博客
05-22 3819
一. 传统方式 以学校院系展示为例，实现在一个页面展示学校的院系组成，一个学校有多个学院，一个学院有多个系。传统方式实现类图如下： 传统方式将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分 层次的。实际上我们的要求是在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案， 不能很好实现的管理的操作，比如对学院、系的添加...
设计模式——组合模式（部分整体模式）
zxcyblbq的博客
12-16 893
设计模式之组合模式详解
设计模式第13讲——组合模式（Composite）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-20 4442
组合模式也成为整体部分模式，是一种结构型设计模式。一、什么是组合模式 二、角色组成 三、优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现 5.0 UML类图 5.1 Expression-组件（Component）5.2 Number-叶子节点（Leaf）5.3 Operation-组合节点（Composite）5.4 testComposite六、总结
C++ 设计模式——设计模式总结
qq_68194402的博客
09-03 985
设计模式是软件设计中常见问题的典型解决方案。它们是经过反复验证的、可重用的代码设计经验，用于解决在特定情境下反复出现的软件设计问题。
软件设计模式——工厂模式
weixin_54859557的博客
09-25 1236
软件设计模式——工厂模式
设计模式之美——教你写出高质量代码
04-10
"设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式，从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助，也是职场发展中的必备技能，无论你使用哪种开发语言。 设计...
状态模式：封装对象状态并改变行为的设计模式
wrxfxdd的博客
10-31 415
状态模式：封装对象状态并改变行为的设计模式
Java设计模式之责任链模式
cxbtdd的博客
11-02 197
责任链模式(Iterator Pattern)是一种行为型设计模式，使多个对象都有机会处理同一个请求，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。处理器链HandlerChain：通过数组或链表组织各个具体的处理器形成一个处理器链，提供添加处理器的方法，并调用处理器的处理方法。2.在请求处理器个数未知的情况下，或者请求处理器可动态配置的情况下，可以使用责任链模式。具体处理器Handler：对抽象处理器的具体实现，重写处理方法，调用处理器链的方法。4、使用责任链模式的样例代码一。
设计模式概述
小林的博客
10-30 398
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
【Java】设计模式——单例设计模式
最新发布
啊松同学的博客
11-02 564
单例设计模式介绍
Java设计模式之观察者模式
cxbtdd的博客
11-02 654
观察者模式（Observer），又叫发布-订阅模式（Publish/Subscribe），是一种行为型模式，定义对象间一对多的依赖关系（注册），使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新（通知）。Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。2.当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值