Java结构型设计模式之组合模式详解


Posted in Java/Android onSeptember 23, 2022

组合模式

组合模式(Composite Pattern)也称为整体-部分(Part-Whole)模式,属于结构型模式。

它的宗旨是通过将单个对象(叶子节点)和组合对象(树枝节点)用相同的接口进行表示,使得客户端对单个对象和组合对象的使用具有一致性。

组合模式一般用来描述整体与部分的关系,它将对象组织到树形结构中,最顶层的节点称为根节点,根节点下面可以包含树枝节点和叶子节点,树枝节点下面又可以包含树枝节点和叶子节点。

应用场景

1.希望客户端可以忽略组合对象与单个对象的差异时。

2.对象层次具备整体和部分,呈树形结构。

例如:树形菜单,文件、文件夹的管理。

优缺点

优点:

1、高层模块调用简单。

2、节点自由增加。

缺点:

1.在使用组合模式时,其叶子和树枝的声明都是实现类,而不是接口,违反了依赖倒置原则。

主要角色

组合模式主要包含3个角色:

1.抽象根节点(Component)

定义系统各层次对象的共有方法和属性,可以预先定义一些默认行为和属性。

2.树枝节点(Composite)

定义树枝节点的行为,存储子节点,组合树枝节点和叶子节点形成一个树形结构。

3.叶子节点(Laf)

叶子节点对象,其下再无分支,是系统层次遍历的最小单位。

组合模式结构

Java结构型设计模式之组合模式详解

分类

组合模式在具体实现上,有两种不同的方式,分别是透明组合模式和安全组合模式。

透明组合模式将公共接口封装到抽象根节点(Component)中,系统所有节点具备一致行为,如果当系统绝大多数层次具备相同的公共行为时,采用透明组合模式会更好。但是为剩下少数层次节点引入不需要的方法。

如果当系统各个层次差异性行为较多或者树节点层次相对稳定时,则采用安全组合模式。

透明组合模式

透明组合模式是把所有公共方法都定义在抽象根节点中,这样做的好处是客户端无需分辨是叶子节点(Leaf)和树枝节点(Composite),它们具备完全一致的接口。缺点是叶子节点(Leaf)会继承得到一些它所不需要(管理子类操作的方法)的方法,这与设计模式接口隔离原则相违背。

创建抽象根节点

把所有可能用到的方法都定义到这个最顶层的抽象类中,但是不写任何逻辑处理的代码,而是直接抛出异常。

禁止使用抽象方法,否则子类必须实现,于是体现不出各个子类的差异。子类只需要重写有差异的方法进行覆盖即可。

举例:分类目录为根节点,具体分类为树枝节点,分类下的商品为叶子节点。

public abstract class Component {
    public String getName(Component component) {
        throw new UnsupportedOperationException("getName is not supported");
    }
    public double getPrice(Component component) {
        throw new UnsupportedOperationException("getPrice is not supported");
    }
    public String print() {
        throw new UnsupportedOperationException("print is not supported");
    }
    public boolean addChild(Component component) {
        throw new UnsupportedOperationException("addChild is not supported");
    }
    public boolean removeChild(Component component) {
        throw new UnsupportedOperationException("removeChild is not supported");
    }
    public Component getChild(int index) {
        throw new UnsupportedOperationException("getChild is not supported");
    }
}

创建树枝节点

public class CompositeCategory extends Component {
    private String name;
    private List<Component> componentList = new ArrayList<Component>();
    public CompositeCategory(String name) {
        this.name = name;
    }
    @Override
    public String print() {
        StringBuilder builder = new StringBuilder(this.name);
        for (Component component : this.componentList) {
            if (component instanceof CompositeCategory) {
                builder.append("\n" + "+-" + component.print());
            } else {
                builder.append("\n" + "+--" + component.print());
            }
        }
        return builder.toString();
    }
    @Override
    public boolean addChild(Component component) {
        return this.componentList.add(component);
    }
    @Override
    public boolean removeChild(Component component) {
        return this.componentList.remove(component);
    }
    @Override
    public Component getChild(int index) {
        return this.componentList.get(index);
    }
}

创建叶子节点

public class CompositeProduct extends Component {
    private String name;
    private Double price;
    public CompositeProduct(String name, Double price) {
        this.name = name;
        this.price = price;
    }
    @Override
    public String print() {
        return this.name + " (¥" + this.price + "元)";
    }
    @Override
    public String getName(Component component) {
        return this.name;
    }
    @Override
    public double getPrice(Component component) {
        return this.price;
    }
}

客户端调用

public static void main(String[] args) {
        // 根节点
        Component root = new CompositeCategory("分类目录");
        // 树枝节点
        Component categoryA = new CompositeCategory("分类A");
        Component categoryB = new CompositeCategory("分类B");
        // 叶子节点
        Component productA = new CompositeProduct("productA ", 20.5);
        Component productB = new CompositeProduct("productB ", 30.5);
        Component productC = new CompositeProduct("productC", 25.5);
        root.addChild(categoryA);
        categoryA.addChild(productA);
        root.addChild(categoryB);
        categoryB.addChild(productB);
        categoryB.addChild(productC);
        System.out.println(root.print());
        System.out.println("-----------------------");
        Component child = root.getChild(1);
        System.out.println(child.print());
        System.out.println("-----------------------");
        root.removeChild(categoryA);
        System.out.println(root.print());
    }

分类目录
+-分类A
+--productA (¥20.5元)
+-分类B
+--productB (¥30.5元)
+--productC (¥25.5元)
-----------------------
分类B
+--productB (¥30.5元)
+--productC (¥25.5元)
-----------------------
分类目录
+-分类B
+--productB (¥30.5元)
+--productC (¥25.5元)

安全组合模式

安全组合模式是只规定系统各个层次的最基础的一致行为,而把组合(树节点)本身的方法(管理子类对象的添加,删除等)放到自身当中。

安全组合模式的好处是接口定义职责清晰,符合设计模式单一职责原侧和接口隔离原则;缺点是客户需要区分树枝节点(Composite)和叶子节点(Leaf),这样才能正确处理各个层次的操作,客户端无法依赖抽象(Component),违背了设计模式依赖倒置原则。

创建抽象根节点

public abstract class Component {
    protected String name;
    public Component(String name) {
        this.name = name;
    }
    public abstract String print();
}

创建树枝节点

public class CompositeCategory extends Component {
    private List<Component> componentList;
    public CompositeCategory(String name) {
        super(name);
        this.componentList = new ArrayList<Component>();
    }
    @Override
    public String print() {
        StringBuilder builder = new StringBuilder(this.name);
        for (Component component : this.componentList) {
            if (component instanceof CompositeCategory) {
                builder.append("\n" + "+-" + component.print());
            } else {
                builder.append("\n" + "+--" + component.print());
            }
        }
        return builder.toString();
    }
    public boolean addChild(Component component) {
        return this.componentList.add(component);
    }
    public boolean removeChild(Component component) {
        return this.componentList.remove(component);
    }
    public Component getChild(int index) {
        return this.componentList.get(index);
    }
}

创建叶子节点

public class CompositeProduct extends Component {
    private Double price;
    public CompositeProduct(String name, Double price) {
        super(name);
        this.price = price;
    }
    @Override
    public String print() {
        return this.name + " (¥" + this.price + "元)";
    }
    public String getName() {
        return this.name;
    }
    public double getPrice() {
        return this.price;
    }
}

客户端调用

public static void main(String[] args) {
        // 根节点
        CompositeCategory root = new CompositeCategory("分类目录");
        // 树枝节点
        CompositeCategory categoryA = new CompositeCategory("分类A");
        CompositeCategory categoryB = new CompositeCategory("分类B");
        // 叶子节点
        CompositeProduct productA = new CompositeProduct("productA", 20.5);
        CompositeProduct productB = new CompositeProduct("productB", 30.5);
        CompositeProduct productC = new CompositeProduct("productC", 25.5);
        root.addChild(categoryA);
        categoryA.addChild(productA);
        root.addChild(categoryB);
        categoryB.addChild(productB);
        categoryB.addChild(productC);
        System.out.println(root.print());
        System.out.println("-----------------------");
        Component child = root.getChild(1);
        System.out.println(child.print());
        System.out.println("-----------------------");
        root.removeChild(categoryA);
        System.out.println(root.print());
    }

分类目录
+-分类A
+--productA (¥20.5元)
+-分类B
+--productB (¥30.5元)
+--productC (¥25.5元)
-----------------------
分类B
+--productB (¥30.5元)
+--productC (¥25.5元)
-----------------------
分类目录
+-分类B
+--productB (¥30.5元)
+--productC (¥25.5元)

到此这篇关于Java结构型设计模式之组合模式详解的文章就介绍到这了,更多相关Java组合模式内容请搜索三水点靠木以前的文章或继续浏览下面的相关文章希望大家以后多多支持三水点靠木!

Java/Android 相关文章推荐
springboot临时文件存储目录配置方式
Jul 01 Java/Android
java调用Restful接口的三种方法
Aug 23 Java/Android
Java基于Dijkstra算法实现校园导游程序
Mar 17 Java/Android
InterProcessMutex实现zookeeper分布式锁原理
Mar 21 Java/Android
SpringBoot中使用Redis作为全局锁示例过程
Mar 24 Java/Android
Android自定义双向滑动控件
Apr 19 Java/Android
解决springboot druid数据库连接失败后一直重连的方法
Apr 19 Java/Android
Spring Boot配合PageHelper优化大表查询数据分页
Apr 20 Java/Android
Java Spring Lifecycle的使用
May 06 Java/Android
Android中的Launch Mode详情
Jun 05 Java/Android
详解Spring Security如何在权限中使用通配符
Jun 28 Java/Android
阿里面试Nacos配置中心交互模型是push还是pull原理解析
Jul 23 Java/Android
Java Redisson多策略注解限流
Sep 23 #Java/Android
Android移动应用开发指南之六种布局详解
Sep 23 #Java/Android
Java中的Kafka为什么性能这么快及4大核心详析
Mybatis 一级缓存和二级缓存原理区别
Sep 23 #Java/Android
Java实现贪吃蛇游戏的示例代码
Sep 23 #Java/Android
Java获取字符串编码格式实现思路
Sep 23 #Java/Android
java获取一个文本文件的编码(格式)信息
Sep 23 #Java/Android
You might like
php array_filter除去数组中的空字符元素
2020/06/21 PHP
Thinkphp使用mongodb数据库实现多条件查询方法
2014/06/26 PHP
Thinkphp中数据按分类嵌套循环实现方法
2014/10/30 PHP
[原创]PHP简单开启curl的方法(测试可行)
2016/01/11 PHP
PHP实现的mysql操作类【MySQL与MySQLi方式】
2017/10/07 PHP
PHP xpath()函数讲解
2019/02/11 PHP
Jquery实现遮罩层的方法
2015/06/08 Javascript
基于JavaScript将表单序列化类型的数据转化成对象的处理(允许对象中包含对象)
2015/12/28 Javascript
详解JavaScript跨域总结与解决办法
2016/10/31 Javascript
jQuery插件FusionCharts绘制2D双折线图效果示例【附demo源码】
2017/04/14 jQuery
JavaScript实现隐藏省略文字效果的方法
2017/04/27 Javascript
JavaScript实现简单的四则运算计算器完整实例
2017/04/28 Javascript
JS实现数组简单去重及数组根据对象中的元素去重操作示例
2018/01/05 Javascript
JavaScript如何对图片进行黑白化
2018/04/10 Javascript
Node.js 使用request模块下载文件的实例
2018/09/05 Javascript
vue实现的仿淘宝购物车功能详解
2019/01/27 Javascript
jQuery事件绑定和解绑、事件冒泡与阻止事件冒泡及弹出应用示例
2019/05/13 jQuery
手把手教你 CKEDITOR 4 实现Dialog 内嵌 IFrame操作详解
2019/06/18 Javascript
新手如何快速理解js异步编程
2019/06/24 Javascript
解决vue组件销毁之后计时器继续执行的问题
2020/07/21 Javascript
对于Python异常处理慎用“except:pass”建议
2015/04/02 Python
Python 高级专用类方法的实例详解
2017/09/11 Python
Django Admin 实现外键过滤的方法
2017/09/29 Python
python3读取excel文件只提取某些行某些列的值方法
2018/07/10 Python
python中将正则过滤的内容输出写入到文件中的实例
2018/10/21 Python
python 上下文管理器及自定义原理解析
2019/11/19 Python
CSS3中几个新增加的盒模型属性使用教程
2016/03/01 HTML / CSS
HTML5 Canvas玩转酷炫大波浪进度图效果实例(附demo)
2016/12/14 HTML / CSS
L’AGENCE官网:加州女装品牌
2018/06/03 全球购物
欧姆龙医疗保健与医疗产品:Omron Healthcare
2020/02/10 全球购物
屈臣氏越南官网:Watsons越南
2021/01/14 全球购物
主要的Ajax框架都有什么
2013/11/14 面试题
应届毕业生求职信范文
2014/05/08 职场文书
英语系毕业生求职信
2014/07/13 职场文书
2015年父亲节活动总结
2015/02/12 职场文书
JS实现简单九宫格抽奖
2022/06/28 Javascript