24组合模式(Composite Pattern)

动机(Motivate):
    组合模式有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。
意图(Intent):
    将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得用户对单个对象和组合对象的使用具有一致性。
                                                                                                                                  -----------《设计模式》GOF
结构图(Struct):

生活中的例子：

适用性：

1．你想表示对象的部分-整体层次结构

2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
代码实现：
这里我们用绘图这个例子来说明Composite模式，通过一些基本图像元素（直线、圆等）以及一些复合图像元素（由基本图像元素组合而成）构建复杂的图形树。在设计中我们对每一个对象都配备一个Draw()方法，在调用时，会显示相关的图形。可以看到，这里复合图像元素它在充当对象的同时，又是那些基本图像元素的一个容器。先看一下基本的类结构图：

图中橙色的区域表示的是复合图像元素。
示意性代码：

1 public abstract class Graphics
2 {
3     protected string _name;
4
5     public Graphics(string name)
6     {
7         this._name = name;
8     }
9     public abstract void Draw();
10 }
11
12 public class Picture : Graphics
13 {
14     public Picture(string name)
15         : base(name)
16     { }
17     public override void Draw()
18     {
19         //
20     }
21
22     public ArrayList GetChilds()
23     {
24         //返回所有的子对象
25     }
26 }

而其他作为树枝构件，实现代码如下：

1 public class Line:Graphics
2 {
3     public Line(string name)
4         : base(name)
5     { }
6
7     public override void Draw()
8     {
9         Console.WriteLine("Draw a" + _name.ToString());
10     }
11 }
12
13 public class Circle : Graphics
14 {
15     public Circle(string name)
16         : base(name)
17     { }
18
19     public override void Draw()
20     {
21         Console.WriteLine("Draw a" + _name.ToString());
22     }
23 }
24
25 public class Rectangle : Graphics
26 {
27     public Rectangle(string name)
28         : base(name)
29     { }
30
31     public override void Draw()
32     {
33         Console.WriteLine("Draw a" + _name.ToString());
34     }
35 }

现在我们要对该图像元素进行处理：在客户端程序中，需要判断返回对象的具体类型到底是基本图像元素，还是复合图像元素。如果是复合图像元素，我们将要用递归去处理，然而这种处理的结果却增加了客户端程序与复杂图像元素内部结构之间的依赖，那么我们如何去解耦这种关系呢？我们希望的是客户程序可以像处理基本图像元素一样来处理复合图像元素，这就要引入Composite模式了，需要把对于子对象的管理工作交给复合图像元素，为了进行子对象的管理，它必须提供必要的Add()，Remove()等方法，类结构图如下：

示意代码：

1 public abstract class Graphics
2 {
3     protected string _name;
4
5     public Graphics(string name)
6     {
7         this._name = name;
8     }
9     public abstract void Draw();
10     public abstract void Add();
11     public abstract void Remove();
12 }
13
14 public class Picture : Graphics
15 {
16     protected ArrayList picList = new ArrayList();
17
18     public Picture(string name)
19         : base(name)
20     { }
21     public override void Draw()
22     {
23         Console.WriteLine("Draw a" + _name.ToString());
24
25         foreach (Graphics g in picList)
26         {
27             g.Draw();
28         }
29     }
30
31     public override void Add(Graphics g)
32     {
33         picList.Add(g);
34     }
35     public override void Remove(Graphics g)
36     {
37         picList.Remove(g);
38     }
39 }
40
41 public class Line : Graphics
42 {
43     public Line(string name)
44         : base(name)
45     { }
46
47     public override void Draw()
48     {
49         Console.WriteLine("Draw a" + _name.ToString());
50     }
51     public override void Add(Graphics g)
52     { }
53     public override void Remove(Graphics g)
54     { }
55 }
56
57 public class Circle : Graphics
58 {
59     public Circle(string name)
60         : base(name)
61     { }
62
63     public override void Draw()
64     {
65         Console.WriteLine("Draw a" + _name.ToString());
66     }
67     public override void Add(Graphics g)
68     { }
69     public override void Remove(Graphics g)
70     { }
71 }
72
73 public class Rectangle : Graphics
74 {
75     public Rectangle(string name)
76         : base(name)
77     { }
78
79     public override void Draw()
80     {
81         Console.WriteLine("Draw a" + _name.ToString());
82     }
83     public override void Add(Graphics g)
84     { }
85     public override void Remove(Graphics g)
86     { }
87 }

这样引入Composite模式后，客户端程序不再依赖于复合图像元素的内部实现了。然而，我们程序中仍然存在着问题，因为Line，Rectangle，Circle已经没有了子对象，它是一个基本图像元素，因此Add()，Remove()的方法对于它来说没有任何意义，而且把这种错误不会在编译的时候报错，把错误放在了运行期，我们希望能够捕获到这类错误，并加以处理，稍微改进一下我们的程序：

1 public class Line : Graphics
2 {
3     public Line(string name)
4         : base(name)
5     { }
6
7     public override void Draw()
8     {
9         Console.WriteLine("Draw a" + _name.ToString());
10     }
11     public override void Add(Graphics g)
12     {
13         //抛出一个我们自定义的异常
14     }
15     public override void Remove(Graphics g)
16     {
17         //抛出一个我们自定义的异常
18     }
19 }

这样改进以后，我们可以捕获可能出现的错误，做进一步的处理。上面的这种实现方法属于透明式的Composite模式，如果我们想要更安全的一种做法，就需要把管理子对象的方法声明在树枝构件Picture类里面，这样如果叶子节点Line，Rectangle，Circle使用这些方法时，在编译期就会出错，看一下类结构图：

示意代码：

1 public abstract class Graphics
2 {
3     protected string _name;
4
5     public Graphics(string name)
6     {
7         this._name = name;
8     }
9     public abstract void Draw();
10 }
11
12 public class Picture : Graphics
13 {
14     protected ArrayList picList = new ArrayList();
15
16     public Picture(string name)
17         : base(name)
18     { }
19     public override void Draw()
20     {
21         Console.WriteLine("Draw a" + _name.ToString());
22
23         foreach (Graphics g in picList)
24         {
25             g.Draw();
26         }
27     }
28
29     public void Add(Graphics g)
30     {
31         picList.Add(g);
32     }
33     public void Remove(Graphics g)
34     {
35         picList.Remove(g);
36     }
37 }
38
39 public class Line : Graphics
40 {
41     public Line(string name)
42         : base(name)
43     { }
44
45     public override void Draw()
46     {
47         Console.WriteLine("Draw a" + _name.ToString());
48     }
49 }
50
51 public class Circle : Graphics
52 {
53     public Circle(string name)
54         : base(name)
55     { }
56
57     public override void Draw()
58     {
59         Console.WriteLine("Draw a" + _name.ToString());
60     }
61 }
62
63 public class Rectangle : Graphics
64 {
65     public Rectangle(string name)
66         : base(name)
67     { }
68
69     public override void Draw()
70     {
71         Console.WriteLine("Draw a" + _name.ToString());
72     }
73 }

这种方式属于安全式的Composite模式，在这种方式下，虽然避免了前面所讨论的错误，但是它也使得叶子节点和树枝构件具有不一样的接口。这种方式和透明式的Composite各有优劣，具体使用哪一个，需要根据问题的实际情况而定。通过Composite模式，客户程序在调用Draw()的时候不用再去判断复杂图像元素中的子对象到底是基本图像元素，还是复杂图像元素，看一下简单的客户端调用：

1 public class App
2 {
3     public static void Main()
4     {
5         Picture root = new Picture("Root");
6
7         root.Add(new Line("Line"));
8         root.Add(new Circle("Circle"));
9
10         Rectangle r = new Rectangle("Rectangle");
11         root.Add(r);
12
13         root.Draw();

Composite模式实现要点：

1．Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化“一对一”的关系，使得客户代码可以一致地处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。

2．将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系，从而更能“应对变化”。

3．Composite模式中，是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中，还是将其定义在“表示对象容器的Composite类”中，是一个关乎“透明性”和“安全性”的两难问题，需要仔细权衡。这里有可能违背面向对象的“单一职责原则”，但是对于这种特殊结构，这又是必须付出的代价。ASP.NET控件的实现在这方面为我们提供了一个很好的示范。

4．Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。

24组合模式(Composite Pattern)相关推荐

【设计模式】组合模式 Composite Pattern
树形结构是软件行业很常见的一种结构,几乎随处可见, 比如: HTML 页面中的DOM,产品的分类,通常一些应用或网站的菜单,Windows Form 中的控件继承关系,Android中的View继承 ...
组合模式(Composite Pattern)
组合模式概述定义:组合多个对象形成树形结构以表示具有部分-整体关系的层次结构.组合模式让客户端可以统一对待单个对象和组合对象.又被成为"部分-整体"(Part-Whole)模式, ...
python 设计模式之组合模式Composite Pattern
#引入一文件夹对我们来说很熟悉,文件夹里面可以包含文件夹,也可以包含文件. 那么文件夹是个容器,文件夹里面的文件夹也是个容器,文件夹里面的文件是对象. 这是一个树形结构咱们生活工作中常用的一种结构 ...
C#设计模式——组合模式(Composite Pattern)
一.概述在软件开发中,我们往往会遇上类似树形结构的对象体系.即某一对象既可能在树形结构中作为叶节点存在,也可能作为分支节点存在.比如在文件系统中,文件是作为叶节点存在,而文件夹就是分支节点.在设计这 ...
组合模式-Composite Pattern
目录组合模式的定义与特点组合模式的结构与实现组合模式的应用实例组合模式的应用场景组合模式的扩展树形结构在软件中随处可见,例如操作系统中的目录结构.应用软件中的菜单.办公系统中的公司组织结构 ...
设计模式:组合模式(Composite Pattern)
组合模式: 又叫部分整体模式, 它创建了对象组的树形结构,将对象组合成树状结构以表示"整体-部分"的层次关系. JDK中的HashMap就使用了组合模式 public abstra ...
组合模式测试组合模式(Composite Pattern)
改章节是一篇关于组合模式测试的帖子像一个树形结构一样使用基本的对象和自己本身构建一个复杂的对象,称为组合模式. 这类模式很轻易学习以及应用到某个系统中.组合模式属于结构设计模式之一,比拟常用.经典的 ...
设计模式(17)：结构型-组合模式(Composite)(2)
设计模式(Design pattern) 是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式 ...
【设计模式自习室】结构型：组合模式 Composite
前言 <设计模式自习室>系列,顾名思义,本系列文章带你温习常见的设计模式.主要内容有: 该模式的介绍,包括: 引子.意图(大白话解释) 类图.时序图(理论规范) 该模式的代码示例:熟悉该模 ...

24组合模式(Composite Pattern)

24组合模式(Composite Pattern)相关推荐

最新文章

热门文章