Composite(组合模式)

文章目录

  • 组合模式
  • UML结构图
  • 组合模式核心
  • 代码实现
  • 总结
    • 优点
    • 缺点

组合模式

组合(Composite)模式是一种对象的行为模式。将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

UML结构图

Composite(组合模式)_第1张图片

组合模式核心

  • Component :组合中的对象声明接口,用于访问和管理Component子部件。
  • Leaf:单个/叶子对象,叶子结点没有子结点。
  • Composite:组合/容器对象,存储子部件和枝节点行为,实现与子部件有关操作,如增加(add)和删除(remove)等,list实现容器,容纳Component对象。

代码实现

抽象构建

	package com.lq.composite.v2;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.composite.v2
	 * @CLASS_NAME: Component
	 * @date 2022/11/17 22:13
	 * @Description:
	 */
	public abstract class Component {
	
	    /**
	     * 子组件对象的功能方法
	     *
	     * @param preStr
	     */
	    public abstract void operiation(String preStr);
	
	
	    public void add(Component child) {
	        // 缺省的实现,抛出异常,因为叶子对象没有这个功能,或子类未实现这个功能
	        throw new UnsupportedOperationException("对象不支持此功能");
	    }
	
	    public void remove(Component child) {
	        // 缺省的实现,抛出异常,因为叶子对象没有这个功能,或子类未实现这个功能
	        throw new UnsupportedOperationException("对象不支持此功能");
	    }
	
	    public Component getChild(int index) {
	        // 缺省的实现,抛出异常,因为叶子对象没有这个功能,或子类未实现这个功能
	        throw new UnsupportedOperationException("对象不支持此功能");
	    }
	}

Leaf节点

	package com.lq.composite.v2;

	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.composite.v2
	 * @CLASS_NAME: Leaf
	 * @date 2022/11/17 22:14
	 * @Description:  Leaf节点
	 */
	public class Leaf extends Component{
	
	    private String name = "";
	
	    public Leaf(String name) {
	        this.name = name;
	    }
	
	    /**
	     * 此处用于输出组件的树形结构
	     */
	    @Override
	    public void operiation(String preStr) {
	        System.out.println(preStr + "-" + name);
	    }
	}

Composite容器

	package com.lq.composite.v2;
	
	import java.util.ArrayList;
	import java.util.List;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.composite.v2
	 * @CLASS_NAME: Composite
	 * @date 2022/11/17 22:15
	 * @Description:
	 */
	public class Composite extends Component {
	
	    private String name = "";
	
	    public Composite(String name) {
	        this.name = name;
	    }
	
	    /**
	     * 用来存储组合对象中包含的子组件对象
	     */
	    private List<Component> childComponents = null;
	
	    /**
	     * 示意方法,此处用于输出组件的树形结构,通常在里面需要实现递归的调用
	     */
	    @Override
	    public void operiation(String preStr) {
	        // 先把自己输出
	        System.out.println(preStr + "-" + name);
	        // 如果还包含其他子组件,那么就输出这些子组件对象
	        if (null != childComponents) {
	            // 添加一个空格,表示向后缩进一个空格
	            preStr += "   ";
	            // 输出当前对象的子组件对象
	            for (Component component : childComponents) {
	                // 递归地进行子组件相应方法的调用,输出每个子组件对象
	                component.operiation(preStr);
	            }
	        }
	
	    }
	
	    /**
	     * 向组合对象中添加组件对象
	     */
	    @Override
	    public void add(Component child) {
	        // 延迟初始化
	        if (null == childComponents) {
	            childComponents = new ArrayList<Component>();
	        }
	        childComponents.add(child);
	    }
	
	    /**
	     * 从组合对象中移除组件对象
	     */
	    @Override
	    public void remove(Component child) {
	        if (null != childComponents) {
	            childComponents.remove(child);
	        }
	    }
	
	    /**
	     * 根据索引获取组合对象中对应的组件对象
	     */
	    @Override
	    public Component getChild(int index) {
	        if (null != childComponents) {
	            if (index >= 0 && index < childComponents.size()) {
	                return childComponents.get(index);
	            }
	        }
	        return null;
	    }
	}

测试

	package com.lq.composite.v2;

	import com.lq.composite.BranchNode;
	import com.lq.composite.LeafNode;
	import com.lq.composite.Node;
	
	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.composite.v2
	 * @CLASS_NAME: Main
	 * @date 2022/11/17 22:17
	 * @Description:
	 */
	public class Main {
	
	    public static void main(String[] args) {
	        // 定义多个Composite组合对象
	        Component root = new Composite("root");
	        Component c1 = new Composite("A");
	        Component c2 = new Composite("B");
	        Component c3 = new Composite("CCC");
	
	        // 定义多个Leaf叶子对象
	        Component leaf1 = new Leaf("AA");
	        Component leaf2 = new Leaf("BB");
	        Component leaf3 = new Leaf("CC");
	        Component leaf4 = new Leaf("AAA");
	        Component leaf5 = new Leaf("BBB");
	        Component leaf6 = new Leaf("C");
	        Component leaf7 = new Leaf("AAAA");
	        Component leaf8 = new Leaf("BBBB");
	
	        // 组合成为树形的对象结构
	        root.add(c1);
	        root.add(c2);
	        root.add(leaf6);
	        c1.add(leaf1);
	        c1.add(leaf2);
	        c1.add(leaf3);
	        c2.add(leaf4);
	        c2.add(leaf5);
	        c2.add(c3);
	        c3.add(leaf7);
	        c3.add(leaf8);
	
	        // 调用根对象的输出功能输出整棵树
	        root.operiation("");
	    }
	}

结果

	-root
	   -A
	      -AA
	      -BB
	      -CC
	   -B
	      -AAA
	      -BBB
	      -CCC
	         -AAAA
	         -BBBB
	   -C

总结

优点

  • 统一了组合对象和叶子对象。
  • 简化了客户端调用,无须区分操作的是组合对象还是叶子对象。
  • 更容易扩展,有了Component的约束,新定义的Composite或Leaf子类能够很容易地与已有的结构一起工作。 使用组合模式的缺点:

缺点

  • 其叶子和树枝的声明都是实现类,而不是接口,违反了依赖倒转原则

你可能感兴趣的:(23种设计模式,组合模式,java)