组合模式：允许你将对象组合成树状结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及组合对象
组合模式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 设计模式 (中国电力出版社)