设计模式笔记（十一）： 组合模式

走进餐厅

学习工作一天累了，想到餐厅里大吃一顿，服务员把菜单拿上来，你看着菜单上面各种分类，大分类下还有小分类，就想这是不是一个树形结构呢？如果用面向对象的方式该如何表示呢？好像可以用继承，嗯，回去试试。然后迅速解决战斗，立马回家打开电脑。

尝试

打开电脑的过程中想了想，先搞个抽象基类（继承不都这样干嘛），然后定义两个子类，一个是菜单项表示具体的饭菜，一个是菜单，表示某个分类的菜单，里面包含一个或多个菜单项，在客户端调用的时候创建一个总菜单，然后将多个菜单加入到这个总菜单中（所以，菜单这里应该包含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 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 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();
    }
}

运行代码可以在控制台上看到结果，基本符合我们的预期（我不贴控制台的信息了，比较多），以上就算是实现了组合模式。

组合模式的特点

1. 封装性好。客户端可以不关心正在操作的类属于整个树结构的哪一块，只需要对具体的对象做一些被允许的操作即可。
2. 可扩展性好。这其实是树形结构的特点，客户端可以任意往下扩展，无论实际业务有多少层级的菜单，都可以在不修改内部代码的情况下继续扩展。
3. 可能不够安全。在这种设计模式下，如果某个恶意的垃圾类继承了抽象基类，那么这个类也可以加入到树形结构中，可能会导致一些麻烦。

小结

现在可以给出组合模式的定义了：组合模式允许你将对象组合树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合.

本系列文章参考书籍是《Head First 设计模式》，文中代码示例出自书中。