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的部分，需要自己好好理解一番。

下面我们先来总结一下我们学过的一些模式：

模式	叙述
策略	封装可互换的行为，并使用委托决定用哪个行为。
适配器	改变一个或多个类的接口
迭代器	提供一个方式遍历集合，无需暴露集合的实现
外观	简化一群类的接口
组合	客户可以将对象的集合以及个别对象一视同仁
观察者	当某个状态发生变化的时候，允许一群对象被通知到。

最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。

面向对象基础

抽象、封装、多态、继承

九大设计原则

设计原则一：封装变化
设计原则二：针对接口编程，不针对实现编程
设计原则三：多用组合，少用继承
设计原则四：为交互对象之间的松耦合设计而努力
设计原则五：对扩展开放，对修改关闭
设计原则六：依赖抽象，不要依赖于具体的类
设计原则七：只和你的密友谈话
设计原则八：别找我，我有需要会找你
设计原则九：类应该只有一个改变的理由

模式

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