走进餐厅
学习工作一天累了，想到餐厅里大吃一顿，服务员把菜单拿上来，你看着菜单上面各种分类，大分类下还有小分类，就想这是不是一个树形结构呢？如果用面向对象的方式该如何表示呢？好像可以用继承，嗯，回去试试。然后迅速解决战斗，立马回家打开电脑。
尝试
打开电脑的过程中想了想，先搞个抽象基类（继承不都这样干嘛），然后定义两个子类，一个是菜单项表示具体的饭菜，一个是菜单，表示某个分类的菜单，里面包含一个或多个菜单项，在客户端调用的时候创建一个总菜单，然后将多个菜单加入到这个总菜单中（所以，菜单这里应该包含CRUD的方法）。这些个菜单既可以加入具体的菜单项，又可以加入下一级的菜单（因为菜单项和菜单的基类都是最开始创建的抽象基类），这样就完成了整个树形结构，如下图所示:
树结构图（摘自书上）
代码实例如下：
//Menu抽象基类，包含基本方法，但是默认都是不支持的，需要子类自己重写
//因为菜单和菜单项和功能有一些差别，设置成抽象方法并不合适
public abstract class MenuComponent {
public void add(MenuComponent component) {
throw new UnsupportedOperationException();
}
public void remove(MenuComponent component) {
throw new UnsupportedOperationException();
}
public MenuComponent getChild(int i) {
throw new UnsupportedOperationException();
}
public String getName() {
throw new UnsupportedOperationException();
}
public String getDesc() {
throw new UnsupportedOperationException();
}
public Double getPrice() {
throw new UnsupportedOperationException();
}
public void print() {
throw new UnsupportedOperationException();
}
}
//菜单项，有名称，描述，价格，但是不可执行添加，删除等操作
public class MenuItem extends MenuComponent {
private String name;
private String desc;
private double price;
public MenuItem(String name, String desc, double price) {
this.name = name;
this.desc = desc;
this.price = price;
}
@Override
public String getName() {
return this.name;
}
@Override
public Double getPrice() {
return this.price;
}
@Override
public String getDesc() {
return this.desc;
}
@Override
public void print() {
System.out.print(" " + getName());
System.out.print(", " + getPrice());
System.out.println(" --" + getDesc());
}
}
//菜单类，有名字，描述，但是没有价格。同时可以执行CRUD操作。
public class Menu extends MenuComponent {
private List<MenuComponent> components = new ArrayList<>();
private String name;
private String desc;
public Menu(String name, String desc) {
this.name = name;
this.desc = desc;
}
@Override
public void add(MenuComponent component) {
components.add(component);
}
@Override
public void remove(MenuComponent component) {
components.remove(component);
}
@Override
public MenuComponent getChild(int i) {
return components.get(i);
}
@Override
public String getName() {
return this.name;
}
@Override
public String getDesc() {
return this.desc;
}
//这里会遍历该菜单下的菜单项，如果该菜单下有菜单，会继续向下层打印，是一种DFS
@Override
public void print() {
System.out.print(" " + getName());
System.out.println(" --" + getDesc());
System.out.println(" ------------------------ ");
Iterator<MenuComponent> iterator = components.iterator();
while (iterator.hasNext()) {
iterator.next().print();
}
System.out.println();
}
@Override
public String toString() {
return "Menu{" +
"components=" + components +
", name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
//测试类
public class Client {
public static void main(String[] args) {
MenuComponent AMenu = new Menu("A", "A menu");
MenuComponent BMenu = new Menu("B", "B menu");
MenuComponent CMenu = new Menu("C", "C menu");
MenuComponent DMenu = new Menu("D", "D menu");
MenuComponent allMenus = new Menu("All", "All menus");
allMenus.add(AMenu);
allMenus.add(BMenu);
allMenus.add(CMenu);
allMenus.add(DMenu);
AMenu.add(new MenuItem("world", "hello, world", 1.0));
AMenu.add(new MenuItem("yeonon", "hello, yeonon", 2.0));
BMenu.add(new MenuItem("fk", "hello, fk", 1.33));
CMenu.add(new MenuItem("lk", "hello, lk", 3.33));
MenuComponent EMenu = new Menu("E", "E menu");
DMenu.add(EMenu);
EMenu.add(new MenuItem("wc", "hello, wc", 2.33));
allMenus.print();
}
}
运行代码可以在控制台上看到结果，基本符合我们的预期（我不贴控制台的信息了，比较多），以上就算是实现了组合模式。
组合模式的特点
- 封装性好。客户端可以不关心正在操作的类属于整个树结构的哪一块，只需要对具体的对象做一些被允许的操作即可。
- 可扩展性好。这其实是树形结构的特点，客户端可以任意往下扩展，无论实际业务有多少层级的菜单，都可以在不修改内部代码的情况下继续扩展。
- 可能不够安全。在这种设计模式下，如果某个恶意的垃圾类继承了抽象基类，那么这个类也可以加入到树形结构中，可能会导致一些麻烦。
小结
现在可以给出组合模式的定义了：组合模式允许你将对象组合树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合.
本系列文章参考书籍是《Head First 设计模式》，文中代码示例出自书中。
