组合模式

组合模式定义：组合模式允许你将对象组合成树形结构来表现“整体/局部”层次结构，组合能让客户以一致的方式处理个别对象以及对象组合。

当涉及到如：菜单，子菜单之类的问题时，会自然而然的想到使用树形结构

类之间的关系确如上图所示，但是这种设计复用性和扩展性都很低：

1，所有的菜单都有各自的add、remove以及getChild实现，复用性很低

2，类型转换问题，菜单完全不知道其包含的子元素的具体类型，这是个大问题（List<Object>）

针对上述2个问题：

1，抽象出共同的父类，以实现一些基本方法的复用

2，隐藏菜单与菜单项之间的差异，在这点，我们可以借鉴装饰者模式，将菜单和菜单项都当做一个菜单，如此一来，共同的父类也出现了

组合模式基本组成：

组件 - Menu、SpecificMenu

叶子节点 - MenuItem

组件可以包含其他组件以及叶子节点

[java] view plain copy

1. public abstract class Menu {  
2.     public void add(){  
3.         throw new UnsupportedOperationException();  
4.     }  
5.       
6.     public void remove(){  
7.         throw new UnsupportedOperationException();  
8.     }  
9.       
10.     public Menu getChild(int i){  
11.         throw new UnsupportedOperationException();  
12.     }  
13.       
14.     public void print(){  
15.         throw new UnsupportedOperationException();  
16.     }  
17. }  

[java] view plain copy

1. public class MenuItem extends Menu {  
2.     private String name;  
3.       
4.     public MenuItem(String name){  
5.         this.name = name;  
6.     }  
7.       
8.     public void print(){  
9.         System.out.println(name);  
10.     }  
11. }  

[java] view plain copy

1. public class SpecificMenu extends Menu {  
2.     private String name;  
3.     private List<Menu> children = new ArrayList<Menu>();  
4.       
5.     public SpecificMenu(String name){  
6.         this.name = name;  
7.     }  
8.       
9.     public void add(Menu menu){  
10.         children.add(menu);  
11.     }  
12.       
13.     public void remove(Menu menu){  
14.         children.remove(menu);  
15.     }  
16.       
17.     public Menu getChild(int i){  
18.         return children.get(i);  
19.     }  
20.       
21.     public void print(){  
22.         Iterator<Menu> it = children.iterator();  
23.         while(it.hasNext()){  
24.             Menu tmp = it.next();  
25.             tmp.print();  
26.         }  
27.     }  
28. }  

[java] view plain copy

1. public class Cilent {  
2.     public static void main(String[] args) {  
3.         MenuItem mocha = new MenuItem("mocha");  
4.         MenuItem espressos = new MenuItem("espressos");  
5.         SpecificMenu coffeeMenu = new SpecificMenu("coffeeMenu");  
6.         coffeeMenu.add(mocha);  
7.         coffeeMenu.add(espressos);  
8.         MenuItem rice = new MenuItem("rice");  
9.         SpecificMenu restaurantMenu = new SpecificMenu("restaurantMenu");  
10.         restaurantMenu.add(coffeeMenu);  
11.         restaurantMenu.add(rice);  
12.         SpecificMenu allMenu = new SpecificMenu("allMenu");  
13.         allMenu.add(restaurantMenu);  
14.         allMenu.print();  
15.     }  
16. }  

测试结果：

[plain] view plain copy

1. mocha  
2. espressos  
3. rice  

通常情况下，一个类具有单一的责任才是好的设计，但是这里，Menu既要扮演菜单，又需扮演菜单项

在组合模式中，通过牺牲了单一责任的设计原则，换取了透明性（对于一个节点，调用方无法确定其是组合还是节点，即组合与节点对用户来说是透明的）

为了保持透明性，组合内所有的对象都必须实现相同的接口，否则将必须考虑哪个对象使用哪个接口，这就失去了组合模式的意义

当然实现相同的接口也意味着有些对象包含一些没有意义的方法调用（如MenuItem通过继承依然拥有add、remove以及getChild方法，但是对叶子节点MenuItem来说，操作子节点的方法似乎是没有意义的，但是换个考虑方向，将MenuItem想象成没有子节点的节点，是不是感觉不一样了？）

可以看出这是一个折中的方案（折中方案很常见，比如为提高处理速度以“空间换时间”），由此也证明设计模式并不是完美无缺的，在使用前有必要仔细审视其带来的影响

PS:

1，什么时候使用组合模式：

有一些对象，它们之间具有“整体/部分”之间的关系，并且想用一致的方式对待整体与局部