八、模板方法模式

• 定义

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

• UML类图
  

  
  说明：
  1、AbstractClass抽象中包含了模板方法，primitiveOpration1() 和primitiveOpration2() 是这个模板方法所用到的操作的抽象版本。
  2、模板方法在实现算法的过程中，用到了两个原语操作。模板方法本身和这两个操作的具体实现之间被解耦了。
  3、ConcreteClass 可以有多个具体类，每一个都实现了模板方法所需要的全部操作。ConcreteClass中的primitiveOpration1()和primitiveOpration2()，当模板方法需要这两个抽象方法时，会调用他们。

简单实现

AbstractMethod 抽象的模板方法定义

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

    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    //该方法在模板的模式中被称作原语操作  具体子类必须实现它们
    protected abstract void addCondiments();

    protected abstract void brew();

    private final void pourInCup() {
        System.out.println("pour water in cup...");
    }

    private final void boilWater() {
        System.out.println("boil water...");
    }
}

ConcreteClass 抽象模板方法子类的实现

public class Tea extends CaffeineBeverage {

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

    @Override
    protected void brew() {
        System.out.println("Adding Tea in Cup...");
    }
}

public class Coffee extends CaffeineBeverage {

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

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

测试类

public class BaristaTest {
    public static void main(String[] args) {
        Tea tea = new Tea();
        Coffee coffee = new Coffee();
        System.out.println("Making tea...");
        tea.prepareRecipe();
        System.out.println("Making coffee...");
        coffee.prepareRecipe();
    }
}

对模板方法进行挂钩操作

CaffeineBeverageWithHook 带钩子的抽象模板方法定义

public abstract class CaffeineBeverageWithHook {

    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        //条件判断语句，该条件是否成立，是有一个customerWantsCondiments()钩子方法决定的。
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void brew();

    abstract void addCondiments();

    private final void boilWater() {
        System.out.println("Boiling water");
    }

    private final void pourInCup() {
        System.out.println("Pouring into cup");
    }
    //这是一个钩子，子类可以覆盖这个方法，但是不见得一定这么做
    boolean customerWantsCondiments() {
        return true;
    }
}

使用钩子 CoffeeWithHook 和 TeaWithHook

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 TeaWithHook extends CaffeineBeverageWithHook {

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

    public void addCondiments() {
        System.out.println("Adding Lemon");
    }
     //钩子的使用
    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) {
        TeaWithHook teaHook = new TeaWithHook();
        CoffeeWithHook coffeeHook = new CoffeeWithHook();
        System.out.println("
Making tea...");
        teaHook.prepareRecipe();
        System.out.println("
Making coffee...");
        coffeeHook.prepareRecipe();
    }
}

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

• 模板方法在Java排序中的实现

  Duck类的排序

public class Duck implements Comparable {
    String name;
    int weight;

    public Duck(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String toString() {
        return name + " weighs " + weight;
    }

    public int compareTo(Object object) {

        Duck otherDuck = (Duck)object;

        if (this.weight < otherDuck.weight) {
            return -1;
        } else if (this.weight == otherDuck.weight) {
            return 0;
        } else { // this.weight > otherDuck.weight
            return 1;
        }
    }
}

测试方法

public class DuckSortTestDrive {
    public static void main(String[] args) {
        Duck[] ducks = { 
                new Duck("Daffy", 8), 
                new Duck("Dewey", 2), 
                new Duck("Howard", 7), 
                new Duck("Louie", 2),
                new Duck("Donald", 10), 
                new Duck("Huey", 2) 
                };
        System.out.println("Before sorting:");
        display(ducks);
        Arrays.sort(ducks);
        System.out.println("
After sorting:");
        display(ducks);
    }

    public static void display(Duck[] ducks) {
        for (int i = 0; i < ducks.length; i++) {
            System.out.println(ducks[i]);
        }
    }
}

说明：
1、数组的排序模板算法已经提供了算法，但是要让这些模板方法知道如何比较duck，需要做的就是实现compareTo() 方法。
2、Array的设计者希望这个方法能够用于所有的数组，所以把sort()变成静态的方法，这样一来，任何数组都可以使用这个方法。
3、因为sort()并不是真正定义在超类中，所以sort()方法需要知道已经实现了这个compareTo()方法，否则无法进行排序。
4、compareTo()方法返回是一个int类型的变量，返回值为 1、0、-1 三种。
5、实现Comparable接口，并重写compareTo()方法。这种模板方法的实现，侧重在于提供一个算法，并让子类实现某些步骤，而数组的排序算法很明显正是如此。
6、在Duck类的排序算法中，由于无法继承Java数组，而sort()方法希望能够用于所有的数组(每个数组都是不同的类)。所以Arrays提供了一个静态方法，而由被排序对象内的每个元素自行提供比较大小的算法步骤。所以，这并不是标准的模板方法的实现，但是符合模板方法的模式精神。（由于不需要继承数组就可以实现排序算法，使得排序变得更有弹性、更有用）
7、在Java API的实现中，java.io的InputStream类有一个read()方法，是由子类实现的，而这个方法又会被 read(byte b[], int off, int len) 模板方法使用。

模板方法模式与策略模式的比较

1、数组对象的排序，这部分和策略模式相似，都是使用对象的组合。但是在策略模式中，所组合的类实现了整个算法，数组所实现的排序算法并不完整，他需要一个类填补compareTo()方法的实现。因此更像模板方法。
2、策略模式并不是使用继承来进行算法的实现，而是通过对象组合的方式，让客户可以选择算法的实现。而模板方法模式是定义一个算法大纲，而由子类定义其中某些步骤的内容。这样一来在算法的个别步骤可以有不同的细节实现，但算法的结构依然维持不变。
3、模板方法模式使用的重复代码，被放入到超类中，好让所有子类共享。而策略模式使用的是委托模型，使用对象组合，使得策略模式更加有弹性。利用策略模式，客户可以在运行时改变自己的算法，而客户所需要的，只是改用不同的策略对象罢了。
4、模板方法模式是经常被使用的模式，因为在超类中提供了一个基础的方法，达到代码的复用，并允许子类指定行为。这在创建框架的时候是非常有用的。
5、模板方法模式由于必须依赖超类中的方法的实现，算作算法的一部分。策略模式不需要依赖，整个算法自己去实现。所以依赖程度相对比较低。

要点

1、“模板方法”定义了算法的步骤，把这些步骤的实现延迟到子类。
2、模板方法为我们提供了一种代码复用的技巧。
3、模板方法的抽象类可以定义具体的方法、抽象方法和钩子。
4、抽象方法由子类实现。
5、钩子是一种方法，它在抽象类中不做事，或者只做默认的事情，子类可以选择要不要去覆盖它。
6、为了防止子类改变模板方法中的算法，可以将模板方法声明为final
7、将决策权放在高层模块中，以便决定如何及何时调用低层模块。
8、在真实实现的模板方法中，模板方法由很多的变体，不要指望一眼辨认出来。
9、策略模式和模板方法模式都封装算法，一个用组合，一个用继承。
10、工厂方法是模板方法的一种特殊版本。