Composite（组合模式）

组合模式

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

UML结构图

组合模式核心

• 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子类能够很容易地与已有的结构一起工作。 使用组合模式的缺点：

缺点

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