了解组合模式

      组合模式，一般就是“整体，部分”的概念，在java与模式中举了一个大家经常听过的故事，很形象，从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，讲的内容是：从前有座山......一直这样下去。从这里看出，整体是这个故事，故事里面的故事则是部分。这也是一个简单的组合模式。

      组合模式把整体和部分的关系用树结果表示出来，使得客户端把一个单独的成分对象和复合对象同等对待。

      组合模式分为安全式和透明式，

     首先看看安全式：

     定义接口

public interface Component {
	 public void sampleOperation();
}

 

树枝构建角色是具体的实现类

public class Composite implements Component {

	private Vector componentVector = new Vector();
	
/**
 * 谋个业务方法
 * */
	public void sampleOperation() {
		Enumeration enumeration = components();
		while (enumeration.hasMoreElements()){
			((Component)(enumeration.nextElement())).sampleOperation();
		}
	}
	/**
	 * 聚集管理方法，增加一个子构建对象
	 * */
	public void add(Component component){
		componentVector.add(component);
//		System.out.println("++++++++++"+componentVector.size());
	}
	/**
	 * 聚集管理方法，删除一个子构建对象
	 * */
	public void remove(Component component){
		componentVector.remove(component);
//		System.out.println("----------"+componentVector.size());
	}
	/**
	 * 聚集管理方法，返回聚集的Enumeration对象
	 * */
	public Enumeration components(){
		System.out.println("**********"+componentVector.size());
		return componentVector.elements();
	}
}

 

这里除基本业务方法外，它增加了，add，与remov方法。此方法可以对子构建进行增加与删除。

树叶构建角色也实现抽象构建角色。

public class Leaf implements Component {

	public void sampleOperation() {
		System.out.println("增加叶子");
	}

}

 

最后通过测试看下

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//操作单一方法
		Leaf l= new Leaf();
		l.sampleOperation();

		//构造根枝
		Composite allc = new Composite();
		//构造次枝
		Composite c1 = new Composite();
		((Composite)allc).add(c1);
		//构造叶子
		((Composite)c1).add(new Leaf());
		((Composite)c1).add(new Leaf());
		((Composite)c1).remove(new Leaf());

		allc.sampleOperation();
	}

}

 

从这个测试看出，在枝节上可以构造枝节，在枝节上可以构造叶子 ，并且可以通过remove方法，去掉枝叶。这个也可以再次创建下一级的枝叶。

 

下来说下几个名词：

抽象构件角色(Component)：这是个抽象类，一般就是个接口，它定义出公共接口，安全模式里，构件角色并不定义管理子对象的方法

树叶构件角色(Leaf)：树叶对象没有下级，只定义原始对象。

树枝构件角色(Composite)：代表参加组合的下级子对象的对象，还定义出了管理方法：add，remove

 

透明式：则是将原来写在composite中的管理方法，写在接口当中，这样实现他时就必须实现这两个管理方法，包括叶子，这样就是说叶子并不能管理树枝，而也有着两个方法，并且客户端可以调用。

 

 

 

评论

2 楼 gaolegao2008 2009-02-26  

<div class="quote_div">
<p>      组合模式，一般就是“整体，部分”的概念，在java与模式中举了一个大家经常听过的故事，很形象，从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事，讲的内容是：从前有座山......一直这样下去。从这里看出，整体是这个故事，故事里面的故事则是部分。这也是一个简单的组合模式。</p>
<p>      组合模式把整体和部分的关系用树结果表示出来，使得客户端把一个单独的成分对象和复合对象同等对待。</p>
<p>      组合模式分为安全式和透明式，</p>
<p>     首先看看安全式：</p>
<p>     定义接口</p>
<pre name="code" class="java">public interface Component {
public void sampleOperation();
}
</pre>
<p> </p>
<p>树枝构建角色是具体的实现类</p>
<pre name="code" class="java">public class Composite implements Component {

private Vector componentVector = new Vector();

/**
* 谋个业务方法
* */
public void sampleOperation() {
Enumeration enumeration = components();
while (enumeration.hasMoreElements()){
((Component)(enumeration.nextElement())).sampleOperation();
}
}
/**
* 聚集管理方法，增加一个子构建对象
* */
public void add(Component component){
componentVector.add(component);
// System.out.println("++++++++++"+componentVector.size());
}
/**
* 聚集管理方法，删除一个子构建对象
* */
public void remove(Component component){
componentVector.remove(component);
// System.out.println("----------"+componentVector.size());
}
/**
* 聚集管理方法，返回聚集的Enumeration对象
* */
public Enumeration components(){
System.out.println("**********"+componentVector.size());
return componentVector.elements();
}
}</pre>
<p> </p>
<p>这里除基本业务方法外，它增加了，add，与remov方法。此方法可以对子构建进行增加与删除。</p>
<p>树叶构建角色也实现抽象构建角色。</p>
<pre name="code" class="java">public class Leaf implements Component {

public void sampleOperation() {
System.out.println("增加叶子");
}

}
</pre>
<p> </p>
<p>最后通过测试看下</p>
<pre name="code" class="java">public class Client {

/**
* @param args
*/
public static void main(String[] args) {
//操作单一方法
Leaf l= new Leaf();
l.sampleOperation();

//构造根枝
Composite allc = new Composite();
//构造次枝
Composite c1 = new Composite();
((Composite)allc).add(c1);
//构造叶子
((Composite)c1).add(new Leaf());
((Composite)c1).add(new Leaf());
((Composite)c1).remove(new Leaf());

allc.sampleOperation();
}

}</pre>
<p> </p>
<p>从这个测试看出，在枝节上可以构造枝节，在枝节上可以构造叶子 ，并且可以通过remove方法，去掉枝叶。这个也可以再次创建下一级的枝叶。</p>
<p> </p>
<p>下来说下几个名词：</p>
<p>抽象构件角色(Component)：这是个抽象类，一般就是个接口，它定义出公共接口，安全模式里，构件角色并不定义管理子对象的方法</p>
<p>树叶构件角色(Leaf)：树叶对象没有下级，只定义原始对象。</p>
<p>树枝构件角色(Composite)：代表参加组合的下级子对象的对象，还定义出了管理方法：add，remove</p>
<p> </p>
<p>透明式：则是将原来写在composite中的管理方法，写在接口当中，这样实现他时就必须实现这两个管理方法，包括叶子，这样就是说叶子并不能管理树枝，而也有着两个方法，并且客户端可以调用。</p>
<p> </p>
<p> </p>
<p> </p>
</div>
<p> </p>

1 楼 hanjs 2008-12-04  

((Composite)allc).add(c1);  
        //构造叶子  
        ((Composite)c1).add(new Leaf());  
        ((Composite)c1).add(new Leaf());  
        ((Composite)c1).remove(new Leaf()); 

不知道我为何需要进行强制类型转换？都已经是这个类型了