JAVA设计模式之组合模式

关键字:设计模式 composite

//Component.java

Java代码

1.       packagecom.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.  }

[java]view plaincopyprint?

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.       packagecom.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.  }

[java]view plaincopyprint?

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.       packagecom.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.  }

[java]view plaincopyprint?

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.       packagecom.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 = newLeaf();

14.  Leaf leaf2 = newLeaf();

15.  Leaf leaf3 = newLeaf();

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.  }