11 CompositePattern（组合模式）
前言：帮助客户用同样的方法遍历不同的集合。
需求：
上次Vander在Panda的帮助下，很好地解决了厨师们的菜单使用不同的集合，解决了不同集合的遍历问题，但是市场竞争真的太激烈了，Vande在九方购物广场的Vander奶茶店也迎来了经营问题，所以现在需要将奶茶店的菜单加入到烧烤菜单中，但是添加会有什么问题呢。我们来看看现在的结构：
很明显，类型不匹配，无法直接将奶茶菜单加入到Barbecue的子菜单中，别无它法，只能请所有的厨师重新设计他们的菜单，来到这里很容易就会想到树形结构，需要这种树形结构能够容纳菜单、子菜单和菜单项，并且需要能够在每个菜单的各项间游走，需要遍历整个菜单，包括子菜单也要遍历。形成的树如下所示：
正当Vander毫无头绪，不知道这个代码要怎么写的时候，Panda大师又来了，这个可以用“组合模式”解决.
下面由我Panda来说明一下组合模式。
组合模式：允许你将对象组合成树形结构来变现“整体/部分”层次结构，组合能让客户以一致的方式处理个别对象以及对象组合。一旦有了丰富的大菜单，我们就可以使用这个模式来“统一处理个别对象和组合对象”。意味着有一个树形结构的菜单（Menu）、子菜单和可能还带有菜单项的子菜单，任何一个菜单都是一种“组合”，因为它既可以包括其他菜单，也可以包括菜单项（MenuItem）。个别对象只是菜单项——并未持有其他对象。菜单就是“节点”，而菜单项就是“叶子节点”。
组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别的对象，使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句话说，就是在大多数情况下，我们可以忽略对象组合和个别对象之间的差别。用一个浅显一点的例子把：就是一个print语句，可以print（叶子节点）、print（根）、print（子菜单）、print（菜单），就是说可以忽略它在树里面的位置。
说了那么多，Vander还是懵逼的，接着Panda继续讲解一下组合模式的一般套路，如下图：
解释一下以上的图，叶子跟组合都是继承于组件，客户端代码主要是跟组件打交道，叶子就是菜单中的每个菜单项，组合指的就是菜单（BarbecueMenu、PizzaMenu等）。使用组合迭代器，就是为了可以在遍历的时候忽略它是菜单还是菜单项，也就是说不管是叶子还是组合对客户端代码来说都是透明的。
这么说可能有点抽象，直接使用吧，用组合模式来重新写菜单：
这种方式比较简单，相当于Menu跟MenuItem将迭代器实现转移到了内部，也就是说遍历什么的操作都在Menu跟MenuItem自身来完成。
Menu：
public class Menu extends MenuComponent {
ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
private String name;
private String desc;
public Menu(String name, String desc) {
this.name = name;
this.desc = desc;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
public void print() {
System.out.println("\nname:" + getName() + "#desc:" + getDesc());
System.out.println("----------------------------------------");
Iterator<MenuComponent> iterator = menuComponents.iterator();
while(iterator.hasNext()) {
MenuComponent menuComponent = iterator.next();
menuComponent.print();
}
}
}
MenuItem：
public class Menu extends MenuComponent {
ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
private String name;
private String desc;
public Menu(String name, String desc) {
this.name = name;
this.desc = desc;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
public void print() {
System.out.println("\nname:" + getName() + "#desc:" + getDesc());
System.out.println("----------------------------------------");
Iterator<MenuComponent> iterator = menuComponents.iterator();
while(iterator.hasNext()) {
MenuComponent menuComponent = iterator.next();
menuComponent.print();
}
}
}
MenuComponent：
public abstract class MenuComponent {
public void add(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public void remove(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public MenuComponent getChild(int i) {
throw new UnsupportedOperationException();
}
public String getName() {
throw new UnsupportedOperationException();
}
public String getDesc() {
throw new UnsupportedOperationException();
}
public double getPrice() {
throw new UnsupportedOperationException();
}
public void print() {
throw new UnsupportedOperationException();
}
}
MenuAdmin：
public class MenuAdmin {
private MenuComponent menuComponent;
public MenuAdmin(MenuComponent menuComponent) {
super();
this.menuComponent = menuComponent;
}
public void print() {
menuComponent.print();
}
}
Main：
public class Main {
public static void main(String args[]) {
Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
barbecueMenu.add(milkTeaMenu);
totalMenu.add(hotPotMenu);
totalMenu.add(barbecueMenu);
totalMenu.add(pizzaMenu);
totalMenu.print();
}
}
MenuComponent：
public abstract class MenuComponent {
public void add(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public void remove(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public MenuComponent getChild(int i) {
throw new UnsupportedOperationException();
}
public String getName() {
throw new UnsupportedOperationException();
}
public String getDesc() {
throw new UnsupportedOperationException();
}
public double getPrice() {
throw new UnsupportedOperationException();
}
public void print() {
throw new UnsupportedOperationException();
}
}
实现效果：
第一种方式是不是违反了单一责任原则，想想看Menu里面是不是使用了迭代器来进行菜单的遍历操作，第一种方式用单一责任原则来换取了透明性（通过让组件的接口同时包含一些管理子节点和叶节点的操作，客户可以将组合和叶节点一视同仁。）
接下来，继续说第二种方式。第二种方式是把遍历的操作实现到了外部，也就是用外部迭代器来完成，我们先来看看图：
这个是当前菜单的树状图，有点复杂，我们简化一下，假设主菜单就只有一个BarbecueMenu：
下面我们用图示的方法，大概画一下整个遍历的过程：
相当于将BarbecueMenuIterator（普通的list迭代器），遍历到MilkteaMenu的时候，这个时候调用next()获取到的就是MilkteaMenu这个组合，然后由于它里面还有很多叶子，所以将这个组合放入堆栈中，再次next的时候，获取到这个组合迭代器的普通迭代器，再继续遍历，最后这个遍历完了，就将MenuteaMenuIterator从堆栈中移除，然后MilkteaCompositeIterator也移出，然后发现BarbecueMenuIterator也遍历完了，也移除，最后整个堆栈就空了，就算遍历完毕了，这里的位置信息不像之前的普通迭代器那样用pos来标记了，这里直接用栈来实现位置信息的存储。
下面我们上代码：（代码看上去不多，但是确实不好理解，请仔细体会递归的味道）
MenuComponent：（与第一种方式一致）
public class MenuItem extends MenuComponent {
private String name;
private String desc;
private double price;
public MenuItem(String name, String desc, double price) {
super();
this.name = name;
this.desc = desc;
this.price = price;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
public double getPrice() {
return price;
}
public void print() {
System.out.println("name:" + getName() + "#desc:" + getDesc() + "#price:" + getPrice());
}
@Override
public Iterator<MenuComponent> createIteractor() {
return new NullIterator();
}
}
Menu：
public class Menu extends MenuComponent {
ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
private String name;
private String desc;
public Menu(String name, String desc) {
this.name = name;
this.desc = desc;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
public void print() {
System.out.println("name:" + getName() + "#desc:" + getDesc());
}
@Override
public Iterator<MenuComponent> createIteractor() {
return new CompositeIterator(menuComponents.iterator());
}
}
NullIterator：
public class NullIterator implements Iterator<MenuComponent> {
public boolean hasNext() {
return false;
}
public MenuComponent next() {
return null;
}
}
ComponentIterator：（重中之中）
public class CompositeIterator implements Iterator<MenuComponent> {
private Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();
public CompositeIterator(Iterator<MenuComponent> iterator) {
stack.push(iterator);
}
public boolean hasNext() {
if(stack.empty()) {
return false;
} else {
Iterator<MenuComponent> iterator = stack.peek();
if(!iterator.hasNext()) {
stack.pop();
return hasNext();
} else {
return true;
}
}
}
public MenuComponent next() {
if(hasNext()) {
Iterator<MenuComponent> itemIterator = stack.peek();
MenuComponent component = itemIterator.next();
if(component instanceof Menu) {
stack.push(component.createIteractor());
}
return component;
}
return null;
}
}
MenuAdmin：
public class MenuAdmin {
private MenuComponent menuComponent;
public MenuAdmin(MenuComponent menuComponent) {
super();
this.menuComponent = menuComponent;
}
public void print() {
Iterator<MenuComponent> iterator =menuComponent.createIteractor();
while(iterator.hasNext()) {
MenuComponent menuComponent = iterator.next();
menuComponent.print();
}
}
}
Main：
public class Main {
public static void main(String args[]) {
Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
barbecueMenu.add(milkTeaMenu);
totalMenu.add(hotPotMenu);
totalMenu.add(barbecueMenu);
totalMenu.add(pizzaMenu);
MenuAdmin menuAdmin = new MenuAdmin(totalMenu);
menuAdmin.print();
}
}
实现效果：
这里有个小细节说明一下，MenuItem使用了NullIterator，由于菜单项已经是子节点了，没有什么好遍历的了，这里如果不用NullIterator，也可以直接返回null，如果直接返回null的话，就需要加入条件判断。但是如果用了NullIterator，就相当于创建了一个没有作用的迭代器。这个迭代器的hasNext()永远都是false，这样操作起来更具有统一性。
以上的代码最主要就是CompositeIterator的部分，需要自己好好理解一番。
下面我们先来总结一下我们学过的一些模式：
| 模式 | 叙述 |
|---|---|
| 策略 | 封装可互换的行为，并使用委托决定用哪个行为。 |
| 适配器 | 改变一个或多个类的接口 |
| 迭代器 | 提供一个方式遍历集合，无需暴露集合的实现 |
| 外观 | 简化一群类的接口 |
| 组合 | 客户可以将对象的集合以及个别对象一视同仁 |
| 观察者 | 当某个状态发生变化的时候，允许一群对象被通知到。 |
最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。
面向对象基础
抽象、封装、多态、继承
九大设计原则
设计原则一：封装变化
设计原则二：针对接口编程，不针对实现编程
设计原则三：多用组合，少用继承
设计原则四：为交互对象之间的松耦合设计而努力
设计原则五：对扩展开放，对修改关闭
设计原则六：依赖抽象，不要依赖于具体的类
设计原则七：只和你的密友谈话
设计原则八：别找我，我有需要会找你
设计原则九：类应该只有一个改变的理由
模式
组合模式：允许你将对象组成树形结构来表现整体/部分的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。
网友评论