设计模式之模板方法模式（二）

来源：cnblogs　　作者：小酒窝　　时间：2019/6/3 9:01:18　　对本文有异议

上一篇我们已经学会了模板方法模式，这次我们继续来深入学习下。毕竟学会只是第一步，还有更进一步的学习和深入等着我们呢。

我们先来看下，对模板方法模式的一个总结的类图：

让我们细看抽象类是如何被定义的，包含了它内含的模板方法和原语操作。

abstract class AbstractClass {
// 这就是模板方法。它被声明为final，以免子类改变这个算法的顺序
    final void templateMethod() {
    // 模板方法定义了一连串的步骤，每个步骤由一个方法代表
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
        hook();
    }
    
    abstract void primitiveOperation1();
    
    abstract void primitiveOperation2();
    
    final void concreteOperation() {
        // 这里是实现
    }
    
    // 这是一个具体的方法，但他什么都不做。我们叫它为hook（钩子），马上就来揭晓它如何使用
    void hook();
}

对模板方法进行挂钩

钩子是一种被声明在抽象类中的方法，但只有空的或者默认的实现。钩子的存在，可以让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类决定。

钩子有很多用途，我们先看其中一个:

public abstract class CaffeineBeverageWithHook {
 
    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;
    }
}

为了使用钩子，我们在子类中覆盖它。在这里，钩子控制了咖啡因饮料是否执行某部分算法；比如，饮料中是否需要加进调料

public class CoffeeWithHook extends CaffeineBeverageWithHook {
 
    public void brew() {
        System.out.println("Dripping Coffee through filter");
    }
 
    public void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }
 
    public boolean customerWantsCondiments() {
        // 询问用户，是否要加调料
        String answer = getUserInput();
        if (answer.toLowerCase().startsWith("y")) {
            return true;
        } else {
            return false;
        }
    }
 
    private String getUserInput() {
        String answer = null;
        System.out.print("Would you like milk and sugar with your coffee (y/n)? ");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        try {
            answer = in.readLine();
        } catch (IOException ioe) {
            System.err.println("IO error trying to read your answer");
        }
        if (answer == null) {
            return "no";
        }
        return answer;
    }
}

上面就是一个钩子，询问顾客是否想要调料？如果需要，就执行内容，否则就不执行。测试代码如下：

public class BeverageTestDrive {
    public static void main(String[] args) {
 
        Tea tea = new Tea();
        Coffee coffee = new Coffee();
 
        System.out.println("\nMaking tea...");
        tea.prepareRecipe();
 
        System.out.println("\nMaking coffee...");
        coffee.prepareRecipe();
 
        TeaWithHook teaHook = new TeaWithHook();
        CoffeeWithHook coffeeHook = new CoffeeWithHook();
 
        System.out.println("\nMaking tea...");
        teaHook.prepareRecipe();
 
        System.out.println("\nMaking coffee...");
        coffeeHook.prepareRecipe();
    }
}

执行结果如下:茶要加调料就给你加上了；咖啡不需要加调料，就没给你加

Making tea...
Boiling water
Steeping the tea
Pouring into cup
Would you like lemon with your tea (y/n)? y
Adding Lemon
Making coffee...
Boiling water
Dripping Coffee through filter
Pouring into cup
Would you like milk and sugar with your coffee (y/n)? n

那么，我们使用钩子的真正目的是什么呢？

钩子有几种用法。如我们之前所说的，钩子可以让子类实现算法中可选的部分，或者在钩子对于子类的实现并不重要的时候，子类可以对此钩子置之不理。钩子的另一个用法，是让子类能够有机会对模板方法中某些即将发生的（或刚刚发生的）步骤做出反应。比方说，名为justReOrderedList()的钩子方法允许子类在内部列表重新组织后执行某些动作（例如在屏幕上重新显示数据）。正如你刚刚看到的，钩子也可以让子类有能力为其抽象类做一些决定。