设计模式-结构型-组合模式

组合模式（composite）：

定义：

　　组合模式又叫部分整体模式，它是一种将对象组合成树状的层次结构模式，用来表示"部分-整体"的关系，使用户对单个对象和组合对象具有一致的访问性。

组合模式的角色：

　　1）抽象构建（component）：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。

　　2）树叶构件（leaf）：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中 声明的公共接口。

　　3）树枝构件（composite）：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 add()、remove()、getchild() 等方法。

　　

 1 internal class program
 2 {
 3     private static void main(string[] args)
 4     {
 5         // create a tree structure
 6         composite root = new composite("root");
 7         root.add(new leaf("leaf a"));
 8         root.add(new leaf("leaf b"));
 9 
10         composite comp = new composite("composite x");
11         comp.add(new leaf("leaf xa"));
12         comp.add(new leaf("leaf xb"));
13 
14         root.add(comp);
15         root.add(new leaf("leaf c"));
16 
17         // add and remove a leaf
18         leaf leaf = new leaf("leaf d");
19         root.add(leaf);
20         root.remove(leaf);
21 
22         // recursively display tree
23         root.display(1);
24     }
25 }
26 
27 public abstract class component
28 {
29     protected string _name;
30 
31     public component(string name)
32     {
33         this._name = name;
34     }
35 
36     public abstract void add(component c);
37 
38     public abstract void remove(component c);
39 
40     public abstract void display(int depth);
41 }
42 
43 public class leaf : component
44 {
45     public leaf(string name)
46         : base(name)
47     {
48     }
49 
50     public override void add(component c)
51     {
52         console.writeline("cannot add to a leaf");
53     }
54 
55     public override void remove(component c)
56     {
57         console.writeline("cannot remove from a leaf");
58     }
59 
60     public override void display(int depth)
61     {
62         console.writeline(new string('-', depth) + _name);
63     }
64 }
65 
66 public class composite : component
67 {
68     private list<component> _children = new list<component>();
69 
70     public composite(string name)
71         : base(name)
72     {
73     }
74 
75     public override void add(component component)
76     {
77         _children.add(component);
78     }
79 
80     public override void remove(component component)
81     {
82         _children.remove(component);
83     }
84 
85     public override void display(int depth)
86     {
87         console.writeline(new string('-', depth) + _name);
88 
89         foreach (component component in _children)
90         {
91             component.display(depth + 2);
92         }
93     }
94 }

 极简版如下，将显示部分可以拿到客户端进行：

 1 internal class program
 2 {
 3     private static void main(string[] args)
 4     {
 5         // create a tree structure
 6         component root = new component("root");
 7         root.add(new component("leaf a"));
 8         root.add(new component("leaf b"));
 9 
10         component comp = new component("composite x");
11         comp.add(new component("leaf xa"));
12         comp.add(new component("leaf xb"));
13 
14         root.add(comp);
15         root.add(new component("leaf c"));
16 
17         // add and remove a leaf
18         component leaf = new component("leaf d");
19         root.add(leaf);
20         root.remove(leaf);
21 
22         // 由客户端显示，component只进行组合
23     }
24 }
25 
26 public class component
27 {
28     protected string _name;
29     private list<component> _children = new list<component>();
30 
31     public component(string name)
32     {
33         this._name = name;
34     }
35 
36     public void add(component c)
37     {
38         _children.add(c);
39     }
40 
41     public void remove(component c)
42     {
43         _children.remove(c);
44     }
45 
46     public list<component> getchild()
47     {
48         return _children;
49     }
50 }

是不是恍然大悟，就是我们在做权限管理的时候用到的一对多的关系。

组合模式的优缺点：

　　优点：

　　　　1）组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的单个对象还是组合对象，这简化了客户端代码；

　　　　2）更容易在组合体内加入新的对象，客户端不会因为加入新的对象而更改源代码，满足ocp原则。

　　缺点：

　　　　1）设计较复杂，客户端需要花更多的时间理清类之间的层次关系；

　　　　2）不容易限制容器中的构件；

　　　　3）不容易用继承的方法来增加构件的新功能。

参考：