Java结构型设计模式之组合模式详解
组合模式
组合模式(Composite Pattern)也称为整体-部分(Part-Whole)模式，属于结构型模式。
它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户端对单个对象和组合对象的使用具有一致性。
组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，最顶层的节点称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点。
应用场景
1.希望客户端可以忽略组合对象与单个对象的差异时。
2.对象层次具备整体和部分，呈树形结构。
例如：树形菜单，文件、文件夹的管理。
优缺点
优点：
1、高层模块调用简单。
2、节点自由增加。
缺点：
1.在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
主要角色
组合模式主要包含3个角色：
1.抽象根节点(Component)
定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。
2.树枝节点(Composite)
定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
3.叶子节点(Laf)
叶子节点对象，其下再无分支，是系统层次遍历的最小单位。
组合模式结构
分类
组合模式在具体实现上，有两种不同的方式，分别是透明组合模式和安全组合模式。
透明组合模式将公共接口封装到抽象根节点(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 实现简单静态资源Web服务器的示例，帮助大家更好的理解和使用Java，感兴趣的朋友可以了解下2020-11-11
这篇文章主要介绍了Java实现消息轰炸的方法 附带源码,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2021-04-04
这篇文章主要介绍了Java利用StringBuffer替换特殊字符的方法实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2021-04-04
这篇文章主要介绍了Mybatis传入List实现批量更新的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2020-10-10
这篇文章主要介绍了Spring Security 内置 Filter的相关知识，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下2020-07-07
这篇文章主要介绍了java更改图片大小示例，方法中指定路径 ,旧文件名称 ,新文件名称,n 改变倍数就可以完成更改图片大小,需要的朋友可以参考下2014-03-03
数组的长度是固定的，无法适应数据变化的需求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList集合类,让我们可以更便捷的存储和操作对象数据。本文就将通过示例聊聊ArrayList类的基础使用，感兴趣的可以了解一下2022-10-10
这篇文章主要为大家详细介绍了如何使用 Java 在 Ubuntu Linux 系统中实现自动切换壁纸的示例程序,感兴趣的小伙伴可以跟随小编一起学习一下2024-11-11
这篇文章主要为大家详细介绍了Spring动态代理实现日志功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2021-08-08
Math类位于java.lang包中，包含很多用于科学计算的类方法，这些方法可以直接通过类名调用。Random类获取随机数，位于java.util包中，本篇带你了解它们的常用方法2022-05-05
最新评论