《Head First 设计模式》：模板方法模式

正文

一、定义

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

要点：

• 模板方法定义了一个算法的步骤，每个步骤都被一个方法所代表，而这几个方法的具体实现可由子类提供。
• 模板方法可确保算法的结构保持不变，同时由子类提供部分实现。

二、实现步骤

1、创建一个抽象类，并定义模板方法

模板方法一般声明为 final，以免子类改变算法的步骤。

抽象类中，可以声明一些钩子方法，子类视情况决定要不要覆盖它们。钩子的存在，可以让子类有能力对算法的不同点进行挂钩，使得模板方法更具有弹性。

/**
 * 抽象类
 */
public abstract class AbstractClass {

    /**
     * 模板方法
     */
    public final void templateMethod() {
        // 公共步骤，由抽象类实现
        commonStep();
        // 依赖于子类的步骤，由子类实现
        step1();
        step2();
        step3();
        // 钩子方法，由子类决定要不要覆盖
        hook();
    }

    /**
     * 步骤1
     */
    public abstract void step1();

    /**
     * 步骤2
     */
    public abstract void step2();

    /**
     * 步骤3
     */
    public abstract void step3();

    /**
     * 公共步骤
     */
    private void commonStep() {
        System.out.println("I'm common step!");
    }

    /**
     * 钩子方法
     */
    public void hook() {
        // 可以空实现，也可以提供默认实现
    }
}

2、创建具体子类，并提供算法步骤的具体实现

（1）具体子类A

/**
 * 具体子类A
 */
public class ConcreteClassA extends AbstractClass{

    @Override
    public void step1() {
        System.out.println("I'm step A1!");
    }

    @Override
    public void step2() {
        System.out.println("I'm step A2!");
    }

    @Override
    public void step3() {
        System.out.println("I'm step A3!");
    }

    @Override
    public void hook() {
        System.out.println("I'm hook step A!");
    }
}

（2）具体子类B

/**
 * 具体子类B
 */
public class ConcreteClassB extends AbstractClass{

    @Override
    public void step1() {
        System.out.println("I'm step B1!");
    }

    @Override
    public void step2() {
        System.out.println("I'm step B2!");
    }

    @Override
    public void step3() {
        System.out.println("I'm step B3!");
    }
}

3、通过使用不同的子类，来确定具体的算法步骤

public class Test {

    public static void main(String[] args) {
        AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();
        System.out.println();
        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();
    }
}

三、举个栗子

1、背景

《星巴兹咖啡师傅训练手册》规定了，准备星巴兹饮料时，必须精确地遵循下面的冲泡法：

星巴兹咖啡冲泡法：

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

星巴兹茶冲泡法：

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

现在，让我们扮演“代码师傅”，写一些代码来创建咖啡和茶。

2、实现

（1）创建咖啡因饮料抽象类，并定义冲泡步骤的方法

/**
 * 咖啡因饮料抽象类
 */
public abstract class CaffeineBeverage {

    /**
     * 准备冲泡法（模板方法）
     */
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    /**
     * 冲泡（依赖于子类的步骤）
     */
    abstract void brew();

    /**
     * 添加调料（依赖于子类的步骤）
     */
    abstract void addCondiments();

    /**
     * 烧水（公共步骤）
     */
    void boilWater() {
        System.out.println("Boiling water");
    }

    /**
     * 把饮料倒进杯子（公共步骤）
     */
    void pourInCup() {
        System.out.println("Pouring into cup");
    }

    /**
     * 顾客是否想要添加调料（钩子方法）
     */
    boolean customerWantsCondiments() {
        return true;
    }
}

（2）创建具体的饮料，并提供具体冲泡步骤的实现

/**
 * 咖啡
 */
public class Caffee extends CaffeineBeverage{

    @Override
    void brew() {
        System.out.println("Dripping Coffee through filter");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }

    @Override
    boolean customerWantsCondiments() {
        String answer = askCustomer();
        if (answer.toLowerCase().startsWith("y")) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 询问顾客
     */
    private String askCustomer() {
        System.out.print("Would you like milk and suger with your coffee (y/n)?");
        String answer = null;
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNext()) {
            answer = scanner.nextLine();
        }
        scanner.close();
        if (answer == null) {
            return "no";
        }
        return answer;
    }
}

/**
 * 茶
 */
public class Tea extends CaffeineBeverage{

    @Override
    void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Lemon");
    }
}

（3）冲泡饮料

public class Test {

    public static void main(String[] args) {
        // 茶
        System.out.println("\nMaking tea...");
        CaffeineBeverage tea = new Tea();
        tea.prepareRecipe();
        // 咖啡
        System.out.println("\nMaking coffee...");
        CaffeineBeverage caffee = new Caffee();
        caffee.prepareRecipe();
    }
}