设计模式之组合模式(Composite)

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

 

组合模式UML图：

组合模式的一种常见的特征就是内部有一个集合，集合当中保存着一系列的自身接口的引用。这样就可以在组合对象中任意新增新的组合对象，最终表现为一种树形结构形态。

 

组合模式通常和迭代器模式一起使用，来遍历某个节点下所有的子节点。

 

下面是一个菜单的例子

首先我们总揽一下该例子程序的类图结构：

事例场景：某餐厅的菜单（OursMenu）包含了中餐菜单（ZhongCanMenu）和西餐菜单（XiCanMenu）两类子菜单，其中ZhongCanMenu中具体的菜肴有红烧肉（HongShaoRou）和水煮鱼（ShuiZhuYu），XiCanMenu中具体的菜肴有意大利面（YiDaLiMian），另外还有一个咖喱鸡饭（GaliJiFan）没有另作分类直接放在了OursMenu当中，现在我们需要列出所有的菜肴的价格。

 

package com.pattern.menu;

/**
 * 菜单接口
 */
public interface Menu {
	/**
	 * 添加菜肴
	 * @param item
	 */
	void addItem(MenuItem item);
	/**
	 * 列印出所有菜肴的价格
	 */
	void printItems();
	/**
	 * 添加一个子菜单
	 * @param xiCanMenu
	 */
	void addSubMenu(Menu xiCanMenu);
}

 

package com.pattern.menu;

/**
 * 菜肴接口
 */
public interface MenuItem {

	/**
	 * 列印菜肴价格
	 */
	void price();
	
}

 

package com.pattern.menu;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 菜单接口抽象类
 */
public abstract class AbstractMenu implements Menu {
	/**
	 * 保存所有子菜单的集合
	 */
	private Collection<Menu> menus = new ArrayList<Menu>();
	/**
	 * 保存当前菜单的菜肴
	 */
	private Collection<MenuItem> menuItems = new ArrayList<MenuItem>();
	
	public void addSubMenu(Menu menu){
		menus.add(menu);
	}

	public void addItem(MenuItem item) {
		menuItems.add(item);
	}

	public void printItems() {
		printMyMenusItems();
		printMyItems();
	}

	/**
	 * 列印出当前菜单中所有子菜单的菜肴
	 */
	private void printMyMenusItems() {
		Iterator<Menu> menusItrator = menus.iterator();
		while (menusItrator.hasNext()) {
			Menu menu = (Menu) menusItrator.next();
			menu.printItems();
		}
	}
	/**
	 * 列印当前菜单中的菜肴
	 */
	private void printMyItems() {
		Iterator<MenuItem> itemsIterator = menuItems.iterator();
		while (itemsIterator.hasNext()) {
			MenuItem menuItem = (MenuItem) itemsIterator.next();
			menuItem.price();
		}
	}

}

 

以下是具体实例类代码：

/**
 * 中餐菜单
 */
public class ZhongCanMenu extends AbstractMenu{

}

/**
 * 西餐菜单
 */
public class XiCanMenu extends AbstractMenu {

}

/**
 * 餐厅总菜单
 */
public class OursMenu extends AbstractMenu {

}

 

/**
 * 咖喱鸡饭
 */
public class GaliJiFan implements MenuItem {

	public void price() {
		System.out.println("GaliJiFan:"+"RMB 25.00");
	}

}

 

/**
 * 红烧肉
 */
public class HongShaoRou implements MenuItem {

	public void price() {
		System.out.println("HongShaoRou:"+"RMB 23.00");
	}

}

 

/**
 * 水煮鱼
 */
public class ShuiZhuYu implements MenuItem {

	public void price() {
		System.out.println("ShuiZhuYu:"+"RMB 48.00");
	}

}

 

/**
 * 意大利面
 */
public class YiDaLiMian implements MenuItem {

	public void price() {
		System.out.println("YiDaLiMian:"+"RMB 203.00");
	}

}

 

Main方法：

package com.pattern.menu;

public class APP {
	public static void main(String[] args) {
		//实例化所有菜肴
		MenuItem hongShaoRou = new HongShaoRou();
		MenuItem shuiZhuYu = new ShuiZhuYu();
		MenuItem yiDaLiMian = new YiDaLiMian();
		MenuItem galiJiFan = new GaliJiFan();
		//实例化所有菜单
		Menu zhongCanMenu = new ZhongCanMenu();
		Menu xiCanMenu = new XiCanMenu();
		Menu oursMenu = new OursMenu();
		//添加菜肴到相关菜单
		xiCanMenu.addItem(yiDaLiMian);
		zhongCanMenu.addItem(shuiZhuYu);
		zhongCanMenu.addItem(hongShaoRou);
		//组合子菜单和菜肴到餐厅总菜单
		oursMenu.addSubMenu(xiCanMenu);
		oursMenu.addSubMenu(zhongCanMenu);
		oursMenu.addItem(galiJiFan);
		//列印所有菜肴价格
		oursMenu.printItems();
	}
}

 

有些参考资料中，为了说明组合这个设计模式，让菜肴和菜单都实现一个接口，显然这是两个不同的对象，必然会导致有些菜单对象的方法根本就不适合菜肴对象，最后通过在不相关的方法实现中抛出UnsupportedOperationException异常来解决这类问题。

这里我将菜单和菜肴分别抽象为两个接口，通过组合关联的方式完成整个菜单结构，仅仅从菜单那边实现组合模式来建立树状结构。这样做的好处是各自履行各自的职责，不会去干一些不相关或者没有意义事情（比如让菜肴去新增一个子菜单），虽然一定程度上有些违背组合这个设计模式的定义，即没有以一致的方式处理个别对象以及组合对象（组合模式的定义），但个人认为合理就好，没必要生搬硬套模式，毕竟模式也有不遵循设计原则的地方（可能是为了达到某个目标而没有遵循设计原则而采取的折中方案），关键是要适合具体的场景。

 

 

参考资料：

Head First 设计模式 (中国电力出版社)