java设计模式7：Composite

安全式的组合模式
涉及到三个角色：
1、抽象构件（Component)：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。组合对象通常把它所包含的子对象当做类型为Component的对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
2、树叶构件（Leaf)：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。
3、树枝构件（Composite):代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add(),remove(),以及components()的声明。

package com.javapatterns.composite;
/**
* @author luhx
*/
public interface Component {
Composite getComposite();
void sampleOperation();
}

package com.javapatterns.composite;
import java.util.Vector;
import java.util.Enumeration;
public class Composite implements Component
{
public Composite getComposite()
{
return this;
}
public void sampleOperation()
{
java.util.Enumeration enumeration = components();
while (enumeration.hasMoreElements())
{
((Component)enumeration.nextElement()).sampleOperation();
}
}
public void add(Component component)
{
componentVector.addElement(component);
}
public void remove(Component component)
{
componentVector.removeElement(component);
}
public Enumeration components()
{
return componentVector.elements();
}
/**
* @associates <{Component}>
* @link aggregation
* @supplierCardinality 0..
* @uml.property name="componentVector"
* @uml.associationEnd multiplicity="(0 -1)" inverse="composite:com.javapatterns.composite.Component"
*/
private Vector componentVector = new java.util.Vector();
}

package com.javapatterns.composite;
public class Leaf implements Component {
public Composite getComposite(){
// Write your code here
return null;
}
public void sampleOperation(){
// Write your code here
}
}
可以看出，树枝构件类给出了add(),remove()以及components()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。由于这个特点，客户端应用程序不可能错误地调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译出错。

透明式的组合模式的结构
与安全模式的组合模式不同的是，透明式的组合模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定的接口。透明式的组合模式的示意性类图如下所示：

涉及到三个角色：
1、抽象构件(Component)：这是一个抽象角色，它给参加组合的对象规定一个接口，规范共有的接口及默认行为。这个接口可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口中，包括add(),remove()以及getChild()之类的方法。
2、树叶构件（Leaf)：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶类会给出add(),remove(),以及getChild()之类的用来管理子类对象的方法的平庸实现。
3、树枝构件（Composite)：代表参加组合的有子对象的对象，定义出这样的对象的行为
package com.javapatterns.composite.transparent;
import java.util.Enumeration;
/**
* @author luhx
*/
public interface Component
{
void sampleOperation();
/**
* @uml.property name="composite"
* @uml.associationEnd inverse="componentVector:com.javapatterns.composite.transparent.Composite"
*/
Composite getComposite();
void add(Component component);
void remove(Component component);
Enumeration components();
}
package com.javapatterns.composite.transparent;
import java.util.Vector;
import java.util.Enumeration;
public class Composite implements Component
{
public Composite getComposite()
{
return this;
}
public void sampleOperation()
{
java.util.Enumeration enumeration = components();
while (enumeration.hasMoreElements())
{
((Component)enumeration.nextElement()).sampleOperation();
}
}
public void add(Component component)
{
componentVector.addElement(component);
}
public void remove(Component component)
{
componentVector.removeElement(component);
}
public Enumeration components()
{
return componentVector.elements();
}
/**
* @associates <{Component}>
* @link aggregation
* @supplierCardinality 0..
* @uml.property name="componentVector"
* @uml.associationEnd multiplicity="(0 -1)" inverse="composite:com.javapatterns.composite.transparent.Component"
*/
private Vector componentVector = new java.util.Vector();
}

package com.javapatterns.composite.transparent;
import java.util.Enumeration;
import java.util.Vector;
public class Leaf implements Component
{
public void sampleOperation()
{
// Write your code here
}
public void add(Component component)
{
componentVector.addElement(component);
}
public void remove(Component component)
{
componentVector.removeElement(component);
}
public Composite getComposite()
{
// Write your code here
return null;
}
public Enumeration components()
{
// Write your code here
return null;
}
/**
* @associates <{Component}>
* @link aggregation
* @supplierCardinality 0..
* @uml.property name="componentVector"
* @uml.associationEnd multiplicity="(0 -1)" elementType="com.javapatterns.composite.transparent.Component"
*/
private Vector componentVector = new java.util.Vector();
}

一个例子（安全式组合模式）：

package com.javapatterns.composite.drawingsafe;
abstract public class Graphics
{
public abstract void draw();
}
package com.javapatterns.composite.drawingsafe;
public class Circle extends Graphics
{
public void draw()
{
//write your code here
}
}
package com.javapatterns.composite.drawingsafe;
public class Line extends Graphics
{
public void draw()
{
//write your code here
}
}
package com.javapatterns.composite.drawingsafe;
public class Rectangle extends Graphics
{
public void draw()
{
//write your code here
}
}

package com.javapatterns.composite.drawingsafe;
import java.util.Vector;
public class Picture extends Graphics
{
/**
* @uml.property name="list"
* @uml.associationEnd multiplicity="(0 -1)" elementType="com.javapatterns.composite.drawingsafe.Graphics"
*/
private Vector list = new Vector(10);
public void draw()
{
for (int i = 0 ; i < list.size(); i++)
{
Graphics g = (Graphics) list.get(i);
g.draw();
}
}
public void add(Graphics g)
{
list.add(g);
}
public void remove(Graphics g)
{
list.remove(g);
}
public Graphics getChild(int i)
{
return (Graphics) list.get(i);
}
}
另一个例子（透明式组合模式）：

package com.javapatterns.composite.drawingtransparent;
abstract public class Graphics
{
public abstract void draw();
public abstract void add(Graphics g);
public abstract void remove(Graphics g);
public abstract Graphics getChild(int i);
}
package com.javapatterns.composite.drawingtransparent;
public class Circle extends Graphics
{
public void draw()
{
//write your code here
}
public void add(Graphics g)
{
//do nothing
}
public void remove(Graphics g)
{
//do nothing
}
public Graphics getChild(int i)
{
return null;
}
}
package com.javapatterns.composite.drawingtransparent;
public class Line extends Graphics
{
public void draw()
{
//write your code here
}
public void add(Graphics g)
{
//do nothing
}
public void remove(Graphics g)
{
//do nothing
}
public Graphics getChild(int i)
{
return null;
}
}

package com.javapatterns.composite.drawingtransparent;
public class Rectangle extends Graphics
{
public void draw()
{
//write your code here
}
public void add(Graphics g)
{
//do nothing
}
public void remove(Graphics g)
{
//do nothing
}
public Graphics getChild(int i)
{
return null;
}
}

package com.javapatterns.composite.drawingtransparent;
import java.util.Vector;
public class Picture extends Graphics
{
/**
* @uml.property name="list"
* @uml.associationEnd multiplicity="(0 -1)" elementType="com.javapatterns.composite.drawingtransparent.Graphics"
*/
private Vector list = new Vector(10);
public void draw()
{
for (int i = 0 ; i < list.size(); i++)
{
Graphics g = (Graphics) list.get(i);
g.draw();
}
}
public void add(Graphics g)
{
list.add(g);
}
public void remove(Graphics g)
{
list.remove(g);
}
public Graphics getChild(int i)
{
return (Graphics) list.get(i);
}
}

延伸阅读