设计模式之组合模式

设计模式之组合模式

1. 什么是组合模式

Composite模式也叫组合模式，是构造型的设计模式之一。通过递归手段来构造树形的对象结构，并可以通过一个对象来访问整个对象树。

换一种说法就是组合模式将对象聚合成树形结构来表现“整体/部分”的层次结构。组合模式能让客户以一致的方式来处理个别对象以及对象组合。
也就是我们可以忽略对象组合与个体对象之间的差别。

组合模式的结构：

• Component （树形结构的节点抽象）

  • 为所有的对象定义统一的接口（公共属性，行为等的定义）

  • 提供管理子节点对象的接口方法

  • [可选]提供管理父节点对象的接口方法

• Leaf （树形结构的叶节点）

• Component的实现子类

• Composite（树形结构的枝节点）

• Component的实现子类

2. 具体实例

在具体的例子中去只看一下具体是怎么实现和使用的。例子都是书上的例子。

这次的实例还是使用的是那个迭代器模式中的例子。具体的就不在描述了，具体放入可以参考那篇文章。

这次呢就是在那个的基础上我们需要添加新的子菜单，不是添加的某一个菜单，而是在一个菜单项中添加一个子菜单。如下图示：

这样的话我们按照原来的迭代器的设计就是需要修改那个DinerMenu,并且还要抽取其中的Item变为类，然后需要这个子类去继承他。而且迭代的方法也需要修改，这样的话太费劲了，而且每加一个子菜单都要进行修改，维护成本太大。所以需要一个新的模式来重新设计他。

怎么设计呢？

就是我们把所有的菜单项都设计成一种结构，然后统一的去迭代他。要想抽象成一种结构的话需要一个统一的超类供继承和扩展。我们这里把整个项目设计成一个树形的结构。每个节点的类型都是相同的。节点是菜单或子菜单，叶子是菜单项需要能够在各个菜单项之间游走，遍历要能够有弹性的在菜单项之间游走。

项目类图结构：

具体代码实现：

首先是所有的节点都需要继承的那个抽象类，也就是所有的菜单项都需要继承的类，把通用的方法全部抽取出来：

public abstract class MenuComponent {

	public String getName() {
		return "";
	}

	public String getDescription() {
		return "";
	}

	public float getPrice() {
		return 0;
	}

	public boolean isVegetable() {
		return false;
	}

	public abstract void print();

	public Iterator getIterator() {
		return new NullIterator();
	}
}

具体的菜单项：

public class MenuItem extends MenuComponent{
	private String name,description;
	private boolean vegetable;
	private float price;
	public MenuItem(String name,String description,boolean vegetable,float price)
	{
		this.name=name;
		this.description=description;
		this.vegetable=vegetable;
		this.price=price;
		
	}
	@Override
	public String getName()
	{
		return name;
	}
	@Override
	public String getDescription()
	{
		return description;
	}
	@Override
	public float getPrice()
	{
		return price;
	}
	@Override
	public boolean  isVegetable()
	{
		return vegetable;
	}
	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println(getName() + "***" + getPrice() + "***"
				+ getDescription());

	}
}

子菜单：

public class DinerMenu extends MenuComponent {
	private final static int Max_Items = 5;
	private int numberOfItems = 0;
	private MenuComponent[] menuItems;

	public DinerMenu() {
		menuItems = new MenuComponent[Max_Items];
		addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
		addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
		addItem("bean soup", "bean&potato salad", true, 3.28f);
		addItem("hotdog", "onions&cheese&bread", false, 3.05f);
		addSubMenu(new SubMenu());
		
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		if (numberOfItems >= Max_Items) {
			System.err.println("sorry,menu is full!can not add another item");
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems++;
		}

	}
	private void addSubMenu(MenuComponent mMenuComponent) {
		if (numberOfItems >= Max_Items) {
			System.err.println("sorry,menu is full!can not add another item");
		} else {
			menuItems[numberOfItems] = mMenuComponent;
			numberOfItems++;
		}

	}
	public Iterator getIterator() {
		return new ComposeIterator(new DinerIterator());
	}

	class DinerIterator implements Iterator {
		private int position;

		public DinerIterator() {
			position = 0;
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			if (position < numberOfItems) {
				return true;
			}

			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuComponent menuItem = menuItems[position];
			position++;
			return menuItem;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub

		}
	}

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("****This is DinerMenu****");
	}
}

public class CakeHouseMenu extends MenuComponent {
	private ArrayList<MenuComponent> menuItems;

	public CakeHouseMenu() {
		menuItems = new ArrayList<MenuComponent>();

		addItem("KFC Cake Breakfast", "boiled eggs&toast&cabbage", true, 3.99f);
		addItem("MDL Cake Breakfast", "fried eggs&toast", false, 3.59f);
		addItem("Stawberry Cake", "fresh stawberry", true, 3.29f);
		addItem("Regular Cake Breakfast", "toast&sausage", true, 2.59f);
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		menuItems.add(menuItem);
	}

	public Iterator getIterator() {
		return new ComposeIterator(menuItems.iterator());
	}

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("****This is CakeHouseMenu****");
	};

	// 其他功能代码

}

等等…

然后需要一个统一的迭代器来遍历这个树，怎么遍历呢？使用堆栈进行遍历？具体的遍历方法可以参考我之前写的二分搜索树的介绍的文章，非递归方式遍历，这里大同小异。下面就是一个组合迭代器，确保所有的子菜单都要包含进来：

public class ComposeIterator implements Iterator {
	private Stack<Iterator> stack = new Stack<Iterator>();

	public ComposeIterator(Iterator iterator) {
		stack.push(iterator);
	}

	@Override
	public boolean hasNext() {
		// TODO Auto-generated method stub
		if (stack.empty()) {
			return false;
		}
		Iterator iterator = stack.peek();
		if (!iterator.hasNext()) {
			stack.pop();
			return hasNext();
		} else {
			return true;
		}
	}

	@Override
	public Object next() {
		// TODO Auto-generated method stub
		if (hasNext()) {
			Iterator iterator = stack.peek();
			MenuComponent mMenuComponent = (MenuComponent) iterator.next();
			stack.push(mMenuComponent.getIterator());
			return mMenuComponent;
		}
		return null;
	}

	@Override
	public void remove() {
		// TODO Auto-generated method stub

	}

}

当我们的菜单中什么都没有，也就是没有需要打印的东西的话怎么办呢？需要设计一个空的迭代器:

public class NullIterator implements Iterator{

	@Override
	public boolean hasNext() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object next() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void remove() {
		// TODO Auto-generated method stub
		
	}

}

前台打印菜单的：

public class Waitress {
	private ArrayList<MenuComponent> iterators = new ArrayList<MenuComponent>();

	public Waitress() {

	}

	public void addComponent(MenuComponent mMenuComponent) {
		iterators.add(mMenuComponent);

	}

	public void printMenu() {
		Iterator iterator;
		MenuComponent menuItem;
		for (int i = 0, len = iterators.size(); i < len; i++) {
			iterators.get(i).print();
			iterator = iterators.get(i).getIterator();

			while (iterator.hasNext()) {
				menuItem = (MenuComponent) iterator.next();
				menuItem.print();
			}

		}

	}

	public void printBreakfastMenu() {

	}

	public void printLunchMenu() {

	}

	public void printVegetableMenu() {

		Iterator iterator;
		MenuComponent menuItem;
		for (int i = 0, len = iterators.size(); i < len; i++) {
			iterators.get(i).print();
			iterator = iterators.get(i).getIterator();

			while (iterator.hasNext()) {
				menuItem = (MenuComponent) iterator.next();
				if (menuItem.isVegetable()) {
					menuItem.print();
				}
			}
		}
	}
}

测试类：

public class MainTest {
	public static void main(String[] args) {
		Waitress mWaitress = new Waitress();
		CakeHouseMenu mCakeHouseMenu = new CakeHouseMenu();
		DinerMenu mDinerMenu = new DinerMenu();
		mWaitress.addComponent(mCakeHouseMenu);
		mWaitress.addComponent(mDinerMenu);
		mWaitress.printVegetableMenu();;
	}
}

通过上面的实例我们就使用组合模式重新设计了原来的项目，通过组合的模式将Waitress 与具体的子菜单进行了解耦，也就是Waitress 只需要使用MenuComponent，而不用去关心具体的子菜单是怎么实现的。

当我们有一系列的对象集合的时候，并且彼此之间还有整体和部分的关系，你需要用一致性的方法来处理这些对象的时候就需要组合模式，例如上面的统一的去遍历所有的菜单对象。而且组合内的所有方法是都要实现一个统一的接口的，要不然客户就需要操心那个对象使用那个接口，失去了组合模式的意义，但是这样子的话其实有些对象也就需要实现一些没有意义的方法。但是你可以让这些方法都返回null或者不处理任何事情就可以了。组合模式一般是使用树形结构这种层次结构。根就是顶层的组合。而且孩子节点也可以有指向父亲节点的指针，这样的设计会使得对象的游走遍历更加的方便。