组合模式——HeadFirst设计模式学习笔记

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

特点：

• 树形结构表示对象组合
• 忽略对象组合和对象个体之间的差别，即相同的操作既可以作用于对象组合，也可以作用与对象个体

注意：

• 因为继承方法中，有些方法只有对叶子节点有意义，而有些方法只对非叶子节点有意义，我们可以将基类的方法默认实现为抛出UnsupportedOperationException，如果方法无意义，则无需修改默认继承就可以了

透明性：

• 组合模式以单一责任原则换取了透明性
• 通过让组件接口同时包含叶子节点和非叶子节点的操作，客户可以将叶子节点和非叶子节点一视同仁，客户不知道节点的类别
• 换取透明性的同时我们同样失去了一些安全性

举例：

实现菜单中的每一項可以是菜单也可以是菜单项

抽象基类包括叶子节点和非叶子节点的全部操作默认实现为Exception

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 getDescription()  
    {  
        throw new UnsupportedOperationException();  
    }  
    public double getPrice()  
    {  
        throw new UnsupportedOperationException();  
    }  
    public boolean isVegetarian()  
    {  
        throw new UnsupportedOperationException();  
    }  
    public void print()  
    {  
        throw new UnsupportedOperationException();  
    }  
}  

菜单项实现，即叶子节点实现

public class MenuItem extends MenuComponent  
{  
    String name;  
    String description;  
    boolean vegetarian;  
    double price;  
  
    public MenuItem(String name, String description, boolean vegetarian,double price)  
    {  
        this.name = name;  
        this.description = description;  
        this.vegetarian = vegetarian;  
        this.price = price;  
    }   
    public String getName()  
    {  
        return name;  
    }  
    public String getDescription()  
    {  
        return description;  
    }  
    public double getPrice()  
    {  
        return price;  
    }  
    public boolean isVegetarian()  
    {  
        return vegetarian;  
    }  
    public void print()  
    {  
        System.out.print("  " + getName());  
        if (isVegetarian())//素食  
        {  
            System.out.print("(v)");  
        }  
        System.out.println(", " + getPrice());  
        System.out.println("     -- " + getDescription());  
    }  
}  

菜单实现，即非叶子节点的实现：

public class Menu extends MenuComponent  
{  
    ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();  
    String name;  
    String description;  
  
    public Menu(String name, String description)  
    {  
        this.name = name;  
        this.description = description;  
    }  
  
    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 getDescription()  
    {  
        return description;  
    }  
  
    public void print()  
    {  
        System.out.print("
" + getName());  
        System.out.println(", " + getDescription());  
        System.out.println("---------------------");  
  
        Iterator iterator = menuComponents.iterator();  
        while (iterator.hasNext())  
        {  
            MenuComponent menuComponent = (MenuComponent) iterator.next();  
            menuComponent.print();  
        }  
    }  
}

组合迭代器：

public class CompositeIterator implements Iterator<MenuComponent> {

    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 = (Iterator<MenuComponent>)stack.peek();
            if (!iterator.hasNext()) {
                stack.pop();
                return hasNext(); //递归调用
            } else {
                return true;
            }
        }
    }
    
    public MenuComponent next() {
        if (hasNext()) {
            Iterator<MenuComponent> iterator = (Iterator<MenuComponent>)stack.peek();
            MenuComponent component = (MenuComponent)iterator.next();
            if (component instanceof Menu) {
                stack.push(component.createIterator());
            }
            return component;
        } else {
            return null;
        }
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
    
}