浅谈设计模式(四)

一、组合模式

组合模式 又叫部分整体模式，它创建了对象组的树形结构。清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。

三个主要的部分：

• MenuComponent：主要定义共同行为，并可以提供默认的行为。
• Menu：组合对象，用于管理底层的叶子。
• MenuItem：叶子节点，最底层。

public abstract class MenuComponent {
    private String name;
    private int level;

    public MenuComponent(String name, int level){
        this.level = level;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public abstract void print();
}

这里需要继承并且组合进来。

public class Menu extends MenuComponent{
    private List<MenuComponent> menuList = new ArrayList<>(); // 管理叶子节点的容器

    public Menu(String name, int level) {
        super(name, level);
    }

    public void addMenu(MenuComponent menuComponent){
        menuList.add(menuComponent);
    }

    @Override
    public void print() {
        System.out.println(this.getName() + "<--->" + this.getLevel());
        for(MenuComponent menu: menuList){
            menu.print();
        }
    }
}

底层的叶子节点

public class MenuItem extends MenuComponent{
    public MenuItem(String name, int level) {
        super(name, level);
    }

    @Override
    public void print() {
        System.out.println(this.getName() + "<--->" + this.getLevel());
    }
}

客户端调用

Menu mainMenu = new Menu("主菜单", 1);

Menu subMenu1 = new Menu("子菜单1", 2);
Menu subMenu2 = new Menu("子菜单2", 2);

subMenu1.addMenu(new MenuItem("啤酒", 3));
subMenu1.addMenu(new MenuItem("红酒", 3));
subMenu2.addMenu(new MenuItem("可乐", 3));
subMenu2.addMenu(new MenuItem("雪碧", 3));

mainMenu.addMenu(subMenu1);
mainMenu.addMenu(subMenu2);

mainMenu.print();

二、外观模式

外观模式也叫过程模式，属于结构性设计模式，其目的是简化用户的使用操作，通过定义一个一致对外的接口，对外屏蔽系统的细节，无需关心内部实现。合理的使用外观模式可以更好的划分系统层次，便于维护。

 FacedPattern 就是外观类，用于封装底层的细节，Cake和Bread就是复杂系统之间的关系。

假设我们需要将复杂的接口进行组合并对外提供简单的接口。

public class Cake {
    public void pre(){
        System.out.println("准备高筋粉");
    }

    public void bake(){
        System.out.println("烤制蛋糕坯");
    }


    public void make(){
        System.out.println("制作蛋糕坯");
    }
    
}

public class Bread {
    public void pre(){
        System.out.println("准备小麦粉");
    }

    public void bake(){
        System.out.println("烤制面包");
    }


    public void make(){
        System.out.println("制作面包");
    }
}

外观类：：将上面不同弄对象的方法进行组合并放在一个共同的方法中。

public class FacedPattern {
    private Cake cake;
    private Bread bread;

    public FacedPattern(){
        this.cake = new Cake();
        this.bread = new Bread();
    }

    public void ready(){
        cake.pre();
        bread.pre();
    }

    public void make(){
        cake.make();
        bread.make();
    }

    public void bake(){
        cake.bake();
        bread.bake();
    }
}

三、模板模式

属于行为型模式，在抽象类中公开定义执行方法的模板，在子类中进行实现；换句话说，定义好一个操作的大概骨架，将实现的细节放到子类中。实现了最大代码复用性。

abstract class Cake{
    public final void prepare(){
        System.out.println("准备面粉");
    }

    public abstract void addMaterial();

    public final void make(){
        System.out.println("制作面包");
    }

    public final void bake(){
        System.out.println("烘烤面包");
    }

    // 钩子方法
    public void isSkip(){
        System.out.println("我是钩子");
    }

    public void build(){
        this.prepare();
        this.skip();
        this.addMaterial();
        this.prepare();
        this.bake();
    }
}

class ChocolateBread extends Cake{
    @Override
    public void addMaterial() {
        System.out.println("添加巧克力");
    }
}