java 设计模式之： 组合模式(Composite)---1 【转】

关键字: 设计模式 composite

//Component.java

Java代码

1. package com.youngmaster.model.Composite;  
2. /** 
3.  * @author youngmaster  
4.  * @E-mail:[e-mail] 
5.  * @version eclipse 3.4 
6.  * @create time：2009-9-13 上午03:24:55 
7.  * 组件抽象角色  
8.  */  
9.   
10. public interface Component {    
11.         
12.     public void run();    
13.     
14. }    

package com.youngmaster.model.Composite;/** * @author youngmaster  * @E-mail:[e-mail] * @version eclipse 3.4 * @create time：2009-9-13 上午03:24:55 * 组件抽象角色  */public interface Component {            public void run();    }  

 

//Leaf.java

Java代码

1. package com.youngmaster.model.Composite;  
2.   
3. /** 
4.  * @author youngmaster  
5.  * @E-mail:[e-mail] 
6.  * @version eclipse 3.4 
7.  * @create time：2009-9-13 上午03:25:54 
8.  * 叶子角色 
9.  */  
10.   
11. public class Leaf implements Component {  
12.   
13.     public void run() {  
14.         System.out.println(" run invoked...");  
15.     }  
16.   
17. }  

package com.youngmaster.model.Composite;/** * @author youngmaster  * @E-mail:[e-mail] * @version eclipse 3.4 * @create time：2009-9-13 上午03:25:54 * 叶子角色 */public class Leaf implements Component {public void run() {System.out.println(" run invoked...");}}

 

//Composite.java

Java代码

1. package com.youngmaster.model.Composite;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. /** 
7.  * @author youngmaster  
8.  * @E-mail:[e-mail] 
9.  * @version eclipse 3.4 
10.  * @create time：2009-9-13 上午03:27:33 
11.  *  
12.  *  组合角色  
13.  * 实现组件角色接口，并且添加，删除的也是组件角色  
14.  *   
15.  * Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component  
16.  *   
17.  * 组合模式主要分为2种  
18.  *   
19.  * 1 透明式  
20.   
21.  * 添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，  
22.  * 而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）  
23.  *   ，因为这些角色中都具备这些方法。  
24.       
25.  *2 安全式  
26.   
27.   *  添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）  
28.  */  
29.   
30. public class Composite implements Component {  
31.   
32.     List<Component> list = new ArrayList<Component>();    
33.       
34.     //添加    
35.     public void addComponent(Component component){    
36.         list.add(component);    
37.     }    
38.     //删除    
39.     public void removeComponent(Component component){    
40.         list.remove(component);    
41.     }    
42.         
43.     //get    
44.     public List<Component> getAll(){    
45.         return list;    
46.     }    
47.         
48.     public void run(){    
49.         for(Component component : list){    
50.             component.run();    
51.         }    
52.     }    
53.   
54. }  

package com.youngmaster.model.Composite;import java.util.ArrayList;import java.util.List;/** * @author youngmaster  * @E-mail:[e-mail] * @version eclipse 3.4 * @create time：2009-9-13 上午03:27:33 *  *  组合角色  * 实现组件角色接口，并且添加，删除的也是组件角色  *   * Composite本来可以再包含Leaf和Composite的。而 Leaf和Composite 又都属于 Component，所以增加，删除 的是Component  *   * 组合模式主要分为2种  *   * 1 透明式   * 添加Component对象的操作定义在Component角色中，这样的话不仅Composite需要实现这些方法，Leaf也需要实现这些方法，  * 而这些方法对于Leaf来说没有任何意义，不过将系统实现统一起来了，因此对用户来说透明（用户无需区分Composite还是Leaf）  *   ，因为这些角色中都具备这些方法。       *2 安全式    *  添加Component对象的操作定义在Composite角色中，这样的话Leaf就无需实现这些方法（因为Leaf本身根本不需要实现这些方法）  */public class Composite implements Component {List<Component> list = new ArrayList<Component>();          //添加      public void addComponent(Component component){          list.add(component);      }      //删除      public void removeComponent(Component component){          list.remove(component);      }            //get      public List<Component> getAll(){          return list;      }            public void run(){          for(Component component : list){              component.run();          }      }  }

 

//Client.java

Java代码

1. package com.youngmaster.model.Composite;  
2.   
3. /** 
4.  * @author youngmaster 
5.  * @E-mail:[e-mail] 
6.  * @version eclipse 3.4 
7.  * @create time：2009-9-13 上午03:29:30 
8.  */  
9. public class Client {  
10.   
11.     public static void main(String[] args) {  
12.   
13.         Leaf leaf1 = new Leaf();  
14.         Leaf leaf2 = new Leaf();  
15.         Leaf leaf3 = new Leaf();  
16.   
17.         Composite composite = new Composite();  
18.   
19.         composite.addComponent(leaf1);  
20.         composite.addComponent(leaf2);  
21.   
22.         Composite composite1 = new Composite();  
23.         composite1.addComponent(composite);  
24.         composite1.addComponent(leaf3);  
25.   
26.         composite1.run();  
27.   
28.     }  
29.   
30. }