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

关键字: 设计模式 composite

//Component.java

Java代码

1. package  com.youngmaster.model.Composite;  
2. /**  
3.  * @author youngmaster   
4.  * @E-mail:youngmaster.fly@gmail.com  
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:youngmaster.fly@gmail.com
 * @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:youngmaster.fly@gmail.com  
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:youngmaster.fly@gmail.com
 * @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:youngmaster.fly@gmail.com  
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:youngmaster.fly@gmail.com
 * @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:youngmaster.fly@gmail.com  
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. }