组合模式

模式动机

    对于树形结构,当容器对象(如文件夹)的某一个方法被调用时,将遍历整个树形结构,寻找也包含这个方法的成员对象(可以是容器对象,也可以是叶子对象,如子文件夹和文件)并调用执行。(递归调用)
    由于容器对象和叶子对象在功能上的区别,在使用这些对象的客户端代码中必须有区别地对待容器对象和叶子对象,而实际上大多数情况下客户端希望一致地处理它们,因为对于这些对象的区别对待将会使得程序非常复杂。
    组合模式描述了如何将容器对象和叶子对象进行递归组合,使得用户在使用时无须对它们进行区分,可以一致地对待容器对象和叶子对象,这就是组合模式的模式动机。

模式定义

    组合模式(Composite Pattern):组合多个对象形成树形结构以表示“整体-部分”的结构层次。组合模式对单个对象(即叶子对象)和组合对象(即容器对象)的使用具有一致性。
    组合模式又可以称为“整体-部分”(Part-Whole)模式,属于对象的结构模式,它将对象组织到树结构中,可以用来描述整体与部分的关系。

模式结构

 

组合模式包含如下角色:
    • Component: 抽象构件
    • Leaf: 叶子构件
    • Composite: 容器构件
    • Client: 客户类

模式分析

    组合模式的关键是定义了一个抽象构件类,它既可以代表叶子,又可以代表容器,而客户端针对该抽象构件类进行编程,无须知道它到底表示的是叶子还是容器,可以对其进行统一处理。
    同时容器对象与抽象构件类之间还建立一个聚合关联关系,在容器对象中既可以包含叶子,也可以包含容器,以此实现递归组合,形成一个树形结构。

 

典型的抽象构件角色代码:

 

1 public abstract class Component
2 {
3     public abstract void add(Component c);
4     public abstract void remove(Component c);
5     public abstract Component getChild(int i);
6     public abstract void operation(); 
7 } 

 

 典型的叶子构件角色代码:

 

 1 public class Leaf extends Component
 2 {
 3     public void add(Component c)
 4     { //异常处理或错误提示 }    
 5         
 6     public void remove(Component c)
 7     { //异常处理或错误提示 }
 8     
 9     public Component getChild(int i)
10     { //异常处理或错误提示 }
11     
12     public void operation()
13     {
14         //实现代码
15     } 
16 } 

 

 

 典型的容器构件角色代码:

 

 1 public class Composite extends Component
 2 {
 3     private ArrayList list = new ArrayList();
 4     
 5     public void add(Component c)
 6     {
 7         list.add(c);
 8     }
 9     
10     public void remove(Component c)
11     {
12         list.remove(c);
13     }
14     
15     public Component getChild(int i)
16     {
17         (Component)list.get(i);
18     }
19     
20     public void operation()
21     {
22         for(Object obj:list)
23         {
24             ((Component)obj).operation();
25         }
26     }     
27 } 

 

 

组合模式实例与解析

实例一:水果盘
    在水果盘(Plate)中有一些水果,如苹果(Apple)、香蕉(Banana)、梨子(Pear),当然大水果盘中还可以有小水果盘,现需要对盘中的水果进行遍历(吃),当然如果对一个水果盘执行“吃”方法,实际上就是吃其中的水果。使用组合模式模拟该场景 。

 

 

实例代码(JAVA):

 

 1 //抽象构建
 2 public abstract class MyElement
 3 {
 4     public abstract void eat();
 5 }
 6 
 7 //容器构建
 8 import java.util.*;
 9 
10 public class Plate extends MyElement
11 {
12     private ArrayList list=new ArrayList();
13     
14     public void add(MyElement element)
15     {
16        list.add(element);    
17     }
18     
19     public void delete(MyElement element)
20     {
21         list.remove(element);
22     }
23 
24     public void eat()
25     {
26         for(Object object:list)
27         {
28             ((MyElement)object).eat();    //递归
29         }
30     }
31 }
32 
33 //叶子构建
34 public class Apple extends MyElement
35 {
36     public void eat()
37     {
38         System.out.println("吃苹果!");
39     }
40 }
41 
42 //叶子构建
43 public class Banana extends MyElement
44 {
45     public void eat()
46     {
47         System.out.println("吃香蕉!");
48     }
49 }
50 
51 //叶子构建
52 public class Pear extends MyElement
53 {
54     public void eat()
55     {
56         System.out.println("吃梨子!");
57     }
58 }
59 
60 //客户端
61 public class Client
62 {
63     public static void main(String a[])
64     {
65         MyElement obj1,obj2,obj3,obj4,obj5;
66         Plate plate1,plate2,plate3;
67         
68         obj1=new Apple();
69         obj2=new Pear();
70         plate1=new Plate();
71         plate1.add(obj1);
72         plate1.add(obj2);
73         
74         obj3=new Banana();
75         obj4=new Banana();
76         plate2=new Plate();
77         plate2.add(obj3);
78         plate2.add(obj4);
79         
80         obj5=new Apple();
81         plate3=new Plate();
82         plate3.add(plate1);
83         plate3.add(plate2);
84         plate3.add(obj5);
85             
86         plate3.eat();
87     }
88 }

 

 运行结果:

 

实例二:文件浏览
    文件有不同类型,不同类型的文件其浏览方式有所区别,如文本文件和图片文件的浏览方式就不相同。对文件夹的浏览实际上就是对其中所包含文件的浏览,而客户端可以一致地对文件和文件夹进行操作,无须关心它们的区别。使用组合模式来模拟文件的浏览操作。

 

模式优缺点

优点
    • 可以清楚地定义分层次的复杂对象,表示对象的全部或部分层次,使得增加新构件也更容易。
    • 客户端调用简单,客户端可以一致的使用组合结构或其中单个对象。
    • 定义了包含叶子对象和容器对象的类层次结构,叶子对象可以被组合成更复杂的容器对象,而这个容器对象又可以被组合,这样不断递归下去,可以形成复杂的树形结构。
    • 更容易在组合体内加入对象构件,客户端不必因为加入了新的对象构件而更改原有代码。
缺点
    • 使设计变得更加抽象,对象的业务规则如果很复杂,则实现组合模式具有很大挑战性,而且不是所有的方法都与叶子对象子类都有关联。
    • 增加新构件时可能会产生一些问题,很难对容器中的构件类型进行限制。

模式适用环境

在以下情况下可以使用组合模式:
    • 需要表示一个对象整体或部分层次,在具有整体和部分的层次结构中,希望通过一种方式忽略整体与部分的差异,可以一致地对待它们。
    • 让客户能够忽略不同对象层次的变化,客户端可以针对抽象构件编程,无须关心对象层次结构的细节。
    • 对象的结构是动态的并且复杂程度不一样,但客户需要一致地处理它们。

模式应用

 
    (1) XML文档解析

 

 1 <?xml version="1.0"?>
 2   <books>
 3     <book>
 4         <author>Carson</author>
 5         <price format="dollar">31.95</price>
 6         <pubdate>05/01/2001</pubdate>
 7     </book>
 8     <pubinfo>
 9         <publisher>MSPress</publisher>
10         <state>WA</state>
11     </pubinfo>
12   </books> 

 

 

    (2) 操作系统中的目录结构是一个树形结构,因此在对文件和文件夹进行操作时可以应用组合模式,例如杀毒软件在查毒或杀毒时,既可以针对一个具体文件,也可以针对一个目录。如果是对目录查毒或杀毒,将递归处理目录中的每一个子目录和文件。
    (3) JDK的AWT/Swing是组合模式在Java类库中的一个典型实际应用。

 

模式扩展

更复杂的组合模式

 

透明组合模式

 

安全组合模式

 

posted @ 2019-01-13 17:33  WindSun  阅读(1343)  评论(3编辑  收藏  举报
博客已停更,文章已转移,点击访问