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);
    }
}