《Head First 设计模式》笔记8

模版方法模式（Template）

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类。模版方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

好莱坞原则：别调用（打电话给）我们，我们会调用（打电话给）你。
（由高层组件决定低层组件的行为，而不是反过来）

栗子

现在你有两种冲泡饮料，分别是咖啡和茶。

咖啡的冲泡过程：
1. 把水煮沸
2. 用沸水冲泡咖啡
3. 把咖啡倒进杯子
4. 加糖和牛奶

茶的冲泡过程：
1. 把水煮沸
2. 用沸水浸泡茶叶
3. 把茶倒进杯子
4. 加柠檬

然后是实现它们的过程：

冲咖啡：

class Coffee {
    public void prepareRecipe() {
        boilWater();
        brewCoffeeGrinds();
        pourInCup();
        addSugarAndMilk();
    }

    public void boilWater() {
        System.out.println("煮沸水");
    }

    public void brewCoffeeGrinds() {
        System.out.println("用咖啡壶泡咖啡");
    }

    public void pourInCup() {
        System.out.println("把咖啡倒进杯子");
    }

    public void addSugarAndMilk() {
        System.out.println("加糖和牛奶");
    }
}

冲茶：

class Tea {
    public void prepareRecipe() {
        boilWater();
        steepTeaBag();
        pourInCup();
        addLemon();
    }

    public void boilWater() {
        System.out.println("煮沸水");
    }

    public void steepTeaBag() {
        System.out.println("用茶壶泡茶");
    }

    public void pourInCup() {
        System.out.println("把茶倒进杯子");
    }

    public void addLemon() {
        System.out.println("加柠檬");
    }
}

很明显，这四步基本差不多。整理后的算法：
1. 把水煮沸
2. 用沸水浸泡 xx
3. 把饮料倒进杯子
4. 给 xx 加适当的调味料

饮料抽象类，其中 1、3 两步都是子类共有的：

abstract class Beverage {
    public void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    public void boilWater() {
        System.out.println("煮沸水");
    }

    public abstract void brew();

    public void pourInCup() {
        System.out.println("把饮料倒进杯子");
    }

    public abstract void addCondiments();
}

然后是继承饮料的咖啡：

class Coffee extends Beverage {
    public void brew() {
        System.out.println("用咖啡壶泡咖啡");
    }

    public void addCondiments() {
        System.out.println("加糖和牛奶");
    }
}

茶：

class Tea extends Beverage {
    public void brew() {
        System.out.println("用茶壶泡茶");
    }

    public void addCondiments() {
        System.out.println("加柠檬");
    }
}

测试

public static void main(String[] args) {
    Tea tea = new Tea();
    tea.prepareRecipe();

    Coffee coffee = new Coffee();
    coffee.prepareRecipe();
}

在模版方法中使用钩子

在上面的栗子中，饮料被强制加入了调味料，但是有时我们就想喝纯咖啡或者纯茶，怎么办呢？ => 可以使用钩子让用户决定是否加调味料。

abstract class Beverage {
    public void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    public void boilWater() {
        System.out.println("煮沸水");
    }

    public abstract void brew();

    public void pourInCup() {
        System.out.println("把饮料倒进杯子");
    }

    public abstract void addCondiments();

    // 该函数就相当于一个钩子
    // 子类可以覆盖该方法从而决定用户是否加调味料
    public boolean customerWantsCondiments() {
        return true;
    }
}