设计模式16---设计模式之组合模式（Composite）（行为型）

1.场景模拟

使用软件模拟大树的根节点和树枝节点和叶子节点
抽象为两类，容器节点和叶子节点

2.不用模式的解决方案

package demo14.composite.example1;
import java.util.*;


/**
 * 组合对象，可以包含其它组合对象或者叶子对象
 */
public class Composite {
	/**
	 * 用来记录包含的其它组合对象
	 */
	private Collection<Composite> childComposite = new ArrayList<Composite>();
	/**
	 * 用来记录包含的其它叶子对象
	 */
	private Collection<Leaf> childLeaf = new ArrayList<Leaf>();
	/**
	 * 组合对象的名字
	 */
	private String name = "";
	/**
	 * 构造方法，传入组合对象的名字
	 * @param name 组合对象的名字
	 */
	public Composite(String name){
		this.name = name;
	}
	/**
	 * 向组合对象加入被它包含的其它组合对象
	 * @param c 被它包含的其它组合对象
	 */
	public void addComposite(Composite c){
		this.childComposite.add(c);
	}
	/**
	 * 向组合对象加入被它包含的叶子对象
	 * @param leaf 被它包含的叶子对象
	 */
	public void addLeaf(Leaf leaf){
		this.childLeaf.add(leaf);
	}
	/**
	 * 输出组合对象自身的结构
	 * @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
	 */
	public void printStruct(String preStr){
		//先把自己输出去
		System.out.println(preStr+"+"+this.name);
		//然后添加一个空格，表示向后缩进一个空格，输出自己包含的叶子对象
		preStr+=" ";
		for(Leaf leaf : childLeaf){
			leaf.printStruct(preStr);
		}
		//输出当前对象的子对象了
		for(Composite c : childComposite){
			//递归输出每个子对象
			c.printStruct(preStr);
		}
	}
}
***********************************************************************************************
package demo14.composite.example1;
/**
 * 叶子对象
 */
public class Leaf {
	/**
	 * 叶子对象的名字
	 */
	private String name = "";
	/**
	 * 构造方法，传入叶子对象的名字
	 * @param name 叶子对象的名字
	 */
	public Leaf(String name){
		this.name = name;
	}
	/**
	 * 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字
	 * @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
	 */
	public void printStruct(String preStr){
		System.out.println(preStr+"-"+name);
	}
}
***************************************************************************************************
package demo14.composite.example1;


public class Client {
	public static void main(String[] args) {
		// 定义所有的组合对象
		Composite root = new Composite("服装");
		Composite c1 = new Composite("男装");
		Composite c2 = new Composite("女装");
		// 定义所有的叶子对象
		Leaf leaf1 = new Leaf("衬衣");
		Leaf leaf2 = new Leaf("夹克");
		Leaf leaf3 = new Leaf("裙子");
		Leaf leaf4 = new Leaf("套装");
		// 按照树的结构来组合组合对象和叶子对象
		root.addComposite(c1);
		root.addComposite(c2);


		c1.addLeaf(leaf1);
		c1.addLeaf(leaf2);


		c2.addLeaf(leaf3);
		c2.addLeaf(leaf4);


		// 调用根对象的输出功能来输出整棵树
		root.printStruct("");
	}
}

3.问题所在

大家很容易就发现了一个问题：那就是必须区分叶子节点和容器节点，无论是客户端还是内部都要区分，那么这样就会使得程序变得复杂，对于功能的扩展也不方便，而且要知道两个类才行，那么我们能不能把他整合成一个类呢，让客户端如下显示呢？答案是可以的。

package demo14.composite.example2;


public class Client {
	public static void main(String[] args) {
		//定义多个Composite对象
		Component root = new Composite();
		Component c1 = new Composite();
		Component c2 = new Composite();
		//定义多个叶子对象
		Component leaf1 = new Leaf();
		Component leaf2 = new Leaf();
		Component leaf3 = new Leaf();
		
		//组和成为树形的对象结构
		root.addChild(c1);
		root.addChild(c2);
		root.addChild(leaf1);
		
		c1.addChild(leaf2);
		c2.addChild(leaf3);
		
		//操作Component对象
		Component o = root.getChildren(1);
		System.out.println(o);
	}
}

4.解决方案的示例代码

很明显，上述客户端的代码就顺眼多了，那么我们改如何实现呢？

4.1首先看结构图

 

4.2组合模式定义

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

4.3示例代码如下

package demo14.composite.example2;


/**
 * 抽象的组件对象，为组合中的对象声明接口，实现接口的缺省行为
 */
public abstract class Component {
	/**
	 * 示意方法，子组件对象可能有的功能方法
	 */
	public abstract void someOperation();


	/**
	 * 向组合对象中加入组件对象
	 * 
	 * @param child
	 *        被加入组合对象中的组件对象
	 */
	public void addChild(Component child) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}


	/**
	 * 从组合对象中移出某个组件对象
	 * 
	 * @param child
	 *        被移出的组件对象
	 */
	public void removeChild(Component child) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}


	/**
	 * 返回某个索引对应的组件对象
	 * 
	 * @param index
	 *        需要获取的组件对象的索引，索引从0开始
	 * @return 索引对应的组件对象
	 */
	public Component getChildren(int index) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}
}
**********************************************************************
package demo14.composite.example2;


import java.util.*;


/**
 * 组合对象，通常需要存储子对象，定义有子部件的部件行为，
 * 并实现在Component里面定义的与子部件有关的操作
 */
public class Composite extends Component {
	/**
	 * 用来存储组合对象中包含的子组件对象
	 */
	private List<Component> childComponents = null;


	/**
	 * 示意方法，通常在里面需要实现递归的调用
	 */
	public void someOperation() {		
		if (childComponents != null){
			for(Component c : childComponents){
				//递归的进行子组件相应方法的调用
				c.someOperation();
			}
		}
	}
	public void addChild(Component child) {
		//延迟初始化
		if (childComponents == null) {
			childComponents = new ArrayList<Component>();
		}
		childComponents.add(child);
	}


	public void removeChild(Component child) {
		if (childComponents != null) {
			childComponents.remove(child);
		}
	}


	public Component getChildren(int index) {
		if (childComponents != null){
			if(index>=0 && index<childComponents.size()){
				return childComponents.get(index);
			}
		}
		return null;
	}
}
**********************************************************************
package demo14.composite.example2;


/**
 * 叶子对象，叶子对象不再包含其它子对象
 */
public class Leaf extends Component {
	/**
	 * 示意方法，叶子对象可能有自己的功能方法
	 */
	public void someOperation() {
		// do something
	}
}
**********************************************************************
package demo14.composite.example2;


public class Client {
	public static void main(String[] args) {
		//定义多个Composite对象
		Component root = new Composite();
		Component c1 = new Composite();
		Component c2 = new Composite();
		//定义多个叶子对象
		Component leaf1 = new Leaf();
		Component leaf2 = new Leaf();
		Component leaf3 = new Leaf();
		
		//组和成为树形的对象结构
		root.addChild(c1);
		root.addChild(c2);
		root.addChild(leaf1);
		
		c1.addChild(leaf2);
		c2.addChild(leaf3);
		
		//操作Component对象
		Component o = root.getChildren(1);
		System.out.println(o);
	}
}

5.组合模式解决场景模拟

代码的修改量并不大，跟示例代码差不多

5.1结构图如下

 

5.2代码如下（基本上同示例代码差不多，就不过多介绍了，注释非常清楚）

package demo14.composite.example3;


/**
 * 抽象的组件对象
 */
public abstract class Component {
	/**
	 * 输出组件自身的名称
	 */
	public abstract void printStruct(String preStr);


	/**
	 * 向组合对象中加入组件对象
	 * 
	 * @param child
	 *        被加入组合对象中的组件对象
	 */
	public void addChild(Component child) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}


	/**
	 * 从组合对象中移出某个组件对象
	 * 
	 * @param child
	 *        被移出的组件对象
	 */
	public void removeChild(Component child) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}


	/**
	 * 返回某个索引对应的组件对象
	 * 
	 * @param index
	 *        需要获取的组件对象的索引，索引从0开始
	 * @return 索引对应的组件对象
	 */
	public Component getChildren(int index) {
		// 缺省的实现，抛出例外，因为叶子对象没有这个功能，或者子组件没有实现这个功能
		throw new UnsupportedOperationException("对象不支持这个功能");
	}
}
*********************************************************************************************
package demo14.composite.example3;
import java.util.*;


/**
 * 组合对象，可以包含其它组合对象或者叶子对象
 */
public class Composite extends Component{
	/**
	 * 用来存储组合对象中包含的子组件对象
	 */
	private List<Component> childComponents = null;
	/**
	 * 组合对象的名字
	 */
	private String name = "";
	/**
	 * 构造方法，传入组合对象的名字
	 * @param name 组合对象的名字
	 */
	public Composite(String name){
		this.name = name;
	}
	
	public void addChild(Component child) {
		//延迟初始化
		if (childComponents == null) {
			childComponents = new ArrayList<Component>();
		}
		childComponents.add(child);
	}
	/**
	 * 输出组合对象自身的结构
	 * @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
	 */
	public void printStruct(String preStr){
		//先把自己输出去
		System.out.println(preStr+"+"+this.name);
		//如果还包含有子组件，那么就输出这些子组件对象
		if(this.childComponents!=null){
			//然后添加一个空格，表示向后缩进一个空格
			preStr+=" ";		
			//输出当前对象的子对象了
			for(Component c : childComponents){
				//递归输出每个子对象
				c.printStruct(preStr);
			}
		}
	}
}
**********************************************************************************************
package demo14.composite.example3;


/**
 * 叶子对象
 */
public class Leaf extends Component {
	/**
	 * 叶子对象的名字
	 */
	private String name = "";


	/**
	 * 构造方法，传入叶子对象的名字
	 * 
	 * @param name
	 *        叶子对象的名字
	 */
	public Leaf(String name) {
		this.name = name;
	}


	/**
	 * 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字
	 * 
	 * @param preStr
	 *        前缀，主要是按照层级拼接的空格，实现向后缩进
	 */
	public void printStruct(String preStr) {
		System.out.println(preStr + "-" + name);
	}
}
********************************************************************************************
package demo14.composite.example3;


public class Client {
	public static void main(String[] args) {
		//定义所有的组合对象
		Component root = new Composite("服装");
		Component c1 = new Composite("男装");
		Component c2 = new Composite("女装");
		//定义所有的叶子对象
		Component leaf1 = new Leaf("衬衣");
		Component leaf2 = new Leaf("夹克");
		Component leaf3 = new Leaf("裙子");
		Component leaf4 = new Leaf("套装");
		//按照树的结构来组合组合对象和叶子对象
		root.addChild(c1);
		root.addChild(c2);
		
		c1.addChild(leaf1);
		c1.addChild(leaf2);
		
		c2.addChild(leaf3);
		c2.addChild(leaf4);
		
		//调用根对象的输出功能来输出整棵树
		root.printStruct("");
	}
}

6.组合模式讲解

6.1要点

目的：客户端不再区分叶子节点和组合对象
关键点：设计一个抽象的组合对象

6.2组合模式本质

统一叶子对象和组合对象