设计模式之组合模式

定义
   将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.

其意图是将对象组合成树形结构以表示部分-整体的层次结构，composite模式使得用户对单个对象和组合对象的使用具有一致性。Composite模式的一个重要思想是递归组合，关键是一个抽象类，它既可以代表组合对象，又可以代表一个被组合的对象。经常在Java开发中遇到的容器就使用了组合模式，一方面组件可以放在容器中，另一方面容器也可以作为组件放在另外的容器中。

 

 

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

为组合中的对象声明接口。

              在适当的情况下，实现所有类共有接口的缺省行为。

              声明一个接口用于访问和管理Componebt 的子组件。

              在递归结构中定义一个接口，用于访问一个父组件，并在合适的情况下实现。

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

                在组合中表示叶节点对象，叶节点对象没有子节点。

                        在组合中定义图元对象的行为。

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

                     定义有子部件的那些部件的行为存储子部件，

                                在Component接口中实现与子部件有关的操作。

                      通过Component接口操纵组合部件的对象。

 

 

 

 

定义接口

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

           }  

         }  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方法，去掉枝叶。这个也可以再次创建下一级的枝叶。

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