设计模式之组合模式
组合模式允许将对象组合成树形结构来表示“整体与部分”的层次结构，能让给客户以一致的方式来处理个别对象以及对象组合。
以菜单为例思考，这个模式可以创建一个树形结构，在同一个结构中处理嵌套菜单和菜单项组，菜单包含子菜单，子菜单下分为菜单项，任何一个菜单都是一种组合，它既可以包含其他菜单，也可以包含菜单项。
菜单类和菜单项类继承同一个父类，继承的方法不同，但是我们可以忽略个别对象和对象组合的区别。
组合模式的类图如下：
下面我们结合迭代器模式和组合模式，实现遍历打印菜单，具体类图如下：
MenuComponent类
import java.util.Iterator;
/**
菜单组件类，菜单项和菜单都要继承的父类。
**/
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 getPrice()
{
throw new UnsupportedOperationException();
}
public void print()
{
throw new UnsupportedOperationException();
}
public Iterator createIterator()
{
throw new UnsupportedOperationException();
}
}
继承了MenuComponent类的Menu类
/**
菜单组件类，菜单项和菜单都要继承的父类。
**/
public class Menu extends MenuComponent
{
ArrayList<MenuComponent> menuComponents;
String name;
public Menu(String name)
{
this.name=name;
menuComponents=new ArrayList<MenuComponent>();
}
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 void print()
{
System.out.println("Menu:"+name);
System.out.println("-----------------");
Iterator iterator=createIterator();
while(iterator.hasNext())
{
MenuComponent menuComponent=(MenuComponent)iterator.next();
menuComponent.print();
}
}
public Iterator createIterator()
{
return new CompositeIterator(menuComponents.iterator());
}
}
继承了MenuComponent类的MenuItem类，相当于菜单项
import java.util.Iterator;
/**
菜单项类，继承了菜单组件类
**/
public class MenuItem extends MenuComponent
{
String name;
String price;
public MenuItem(String name,String price)
{
this.name=name;
this.price=price;
}
public String getName()
{
return name;
}
public String getPrice()
{
return price;
}
public void print()
{
System.out.println(name+":"+price);
}
public Iterator createIterator()
{
return new NullIterator();
}
}
CompositeIterator类,作为菜单的迭代器
import java.util.*;
public class CompositeIterator implements Iterator
{
Stack stack;
public CompositeIterator(Iterator iterator)
{
stack=new Stack();
stack.push(iterator);
}
public Object next()
{
if(hasNext())
{
Iterator iterator=(Iterator)stack.peek();
MenuComponent menuComponent=(MenuComponent)
iterator.next();
if(menuComponent instanceof Menu)
{
stack.push(menuComponent.createIterator());
}
return menuComponent;
}
else
return null;
}
public boolean hasNext()
{
if(stack.isEmpty())
{
return false;
}
else
{
Iterator iterator=(Iterator)stack.peek();
if(!iterator.hasNext())
{
stack.pop();
return hasNext();
}
else
{
return true;
}
}
}
public void remove()
{
throw new UnsupportedOperationException();
}
}
NullIterator类，作为菜单项的迭代器
import java.util.Iterator;
public class NullIterator implements Iterator
{
public Object next()
{
return null;
}
public boolean hasNext()
{
return false;
}
public void remove()
{
throw new UnsupportedOperationException();
}
}
Waitress类，大大降低了Waitress类与菜单之间的耦合度，Waitress类只需要知道根节点就可以了。
import java.util.Iterator;
/**
Client
**/
public class Waitress
{
MenuComponent menus;
public Waitress(MenuComponent menuComponent)
{
this.menus=menuComponent;
}
public void printMenu()
{
menus.print();
}
}
测试类
package com.qingfei.composite;
public class Test
{
public static void main(String[] args)
{
MenuComponent menus=new Menu("all Menu");
MenuComponent dinerMenu=new Menu("Diner Menu");
MenuComponent pancakeMenu=new Menu("Pancake Menu");
MenuComponent cafeMenu=new Menu("cafe Menu");
menus.add(dinerMenu);
menus.add(pancakeMenu);
dinerMenu.add(new MenuItem("noodle","10"));
dinerMenu.add(new MenuItem("rice","20"));
dinerMenu.add(new MenuItem("soup","5"));
cafeMenu.add(new MenuItem("latte","30"));
cafeMenu.add(new MenuItem("mocha","25"));
pancakeMenu.add(new MenuItem("pizza","50"));
pancakeMenu.add(new MenuItem("cheese burger","20"));
pancakeMenu.add(cafeMenu);
Waitress service=new Waitress(menus);
service.printMenu();
}
}
结果是
在组合模式中，客户并不需要知道具体有哪些类，只需要知道一个接口，不需要知道哪些是父对象哪些是子对象，也就不需要写大量的判断语句了。
