设计模式08—模板方法模式

上一篇 《适配器模式与外观模式》

8.模板方法模式

直到目前，我们的议题都绕着封装转;我们已经封装了对象创建、方法调用、复杂接口、鸭子、比萨……接下来呢我们将要深入封装算法块，好让子类可以在任何时候都可以将自己挂接进运算里。我们甚至会在本章学到一个受到好莱坞影响而启发的设计原则。
其主要作用就是用于将我们的算法封装起来

8.1 通过冲泡茶和冲泡咖啡来引入算法的封装

茶和咖啡的冲泡方式非常相似，大致如下：

接下来我们看一看冲泡咖啡的代码

/**
 * 煮咖啡
 */
public class Coffee {
    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("加牛奶和糖");
    }
}

煮茶类代码

/**
 * 煮茶类
 */
public class Tea {
    void prepareRecipe() {
        boilWater();
        steepTeaBag();
        addLemon();
        pourInCup();
    }

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

    public void steepTeaBag() {
        System.out.println("将茶叶加入沸水中");
    }

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

    public void pourInCup() {
        System.out.println("将茶水倒入杯子中");
    }

}

注意：由于boilWater(),pourInCup()在两个类中的方法完全一样，所以此处出现了重复代码
我们接下来的工作就是将共同的部分抽取出来，放在一个基类中。

但是值得我们注意的是两份冲泡方法都采用了相同的算法

下面我们要想尽办法将prepareRecipe()方法抽象化。

8.2 抽象prepareRecipe()

1.我们所遇到的第一个问题，就是咖啡使用brewCoffeeGrinds()和addSugarAndMilk()方法,而茶使用steepTeaBag()和addLemon()方法。

让我们来思考这一点:浸泡（steep)和冲泡(brew）差异其实不大。所以我们给它一个新的方法名称，比方说brew()，然后不管是泡茶或冲泡咖啡我们都用这个名称。类似地，加糖和牛奶也和加柠檬很相似:都是在饮料中加入调料。让我们也给它一个新的方法名称来解决这个问题，就叫做addCondiments()好了。这样一来，新的prepareRecipe()方法看起来就像这样:

2.现在我们有了新的prepareRecipe()方法，但是需要让它能够符合代码。要想这么做，我们先从CaffeineBeverage（咖啡因饮料）超类开始:

/**
 * 咖啡因饮料是一个抽象类
 */
public abstract class CaffeineBeverage {
    /**
     * 现在．用同一个prepareRecipe()方法来处理茶和咖啡。piepareRecipe()被声明为final．
     * 因为我们不希望子类覆盖这个方法!我们将步骤2和步骤4泛化成为brew()和addCondiments()。
     */
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    /**
     * 为咖啡和茶处理这些方法的做法不同，所以这两个方法必须被声明为抽象，剩余余的东西留给子类去操心。
     */
    abstract void brew();

    abstract void addCondiments();

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

    void pourInCup() {
        System.out.println("将音频倒入杯中");
    }
}

3.最后，我们需要处理咖啡和茶类了。这两个类现在都是依赖超类（咖啡因饮料）来处理冲泡法，所以只需要自行处理冲泡和添加调料部分:

Tea

/**
 * 茶和咖啡都是继承自咖啡因饮料
 */
public class Tea extends CaffeineBeverage {
    @Override
    public void brew() {
        System.out.println("将茶叶放入沸水中");
    }

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

Coffee

public class Coffee extends CaffeineBeverage {
    @Override
    public void brew() {
        System.out.println("将咖啡粉放入沸水中");
    }

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

我们在上面的操作中做了些什么，下面我用一张图就很直观的显示了我们做了什么

8.3 认识模板方法

其实我们刚刚实现的就是模板方法模式，让我们看看咖啡因饮料的结构

下面我们通过模板方法来冲泡茶和咖啡

public class BeverageTestDrive {
    public static void main(String[] args) {
        Tea tea = new Tea();
        Coffee coffee = new Coffee();
        System.out.println("开始制作茶");
        System.out.println("----------------------------");
        tea.prepareRecipe();
        System.out.println("----------------------------");
        System.out.println("开始制作咖啡");
        System.out.println("----------------------------");
        coffee.prepareRecipe();
        System.out.println("----------------------------");

    }
}

输出结果如下：

模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。
我们为什么要引入模板方法？

8.4 定义模板方法模式

这个模式是用来创建一个算法的模板。什么是模板?
其实模板就是一个方法。更具体地说，这个方法将算法定义成一组步骤，其中的任何步骤都可以是抽象的，由子类负责实现。这可以确保算法的结构保持不变，同时由子类提供部分实现。
让我们细看抽象类是如何被定义的

/**
 * 这就是我们的抽象类，他被声明为抽象，用来作为基类
 * 其子类必须实现其操作
 */
public abstract class AbstractClass {
    /**
     * 这就是模板方法。
     * 他被声明为final，以免子类改变这个算法的顺序
     */
    final void templateMethod() {
        /**模板方法定义了一连串的步骤，每一个步骤由一个方法代表。**/
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
    }

    /**
     * 在这个范例中有两个原语操作，具体子类必须实现他们
     */
    abstract void primitiveOperation1();

    abstract void primitiveOperation2();

    void concreteOperation() {
        //这里是实现
    }
}

接下来我们在靠近一点详细看看抽象类可以有哪些类型的方法

/**
 * 我们加入了一个新方法调用，改变了templateMethod
 */
public abstract class AbstractClassHook {
    /**
     * 这就是模板方法。
     * 他被声明为final，以免子类改变这个算法的顺序
     */
    final void templateMethod() {
        /**模板方法定义了一连串的步骤，每一个步骤由一个方法代表。**/
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
        hook();
    }

    /**
     * 在这个范例中有两个原语操作，具体子类必须实现他们
     */
    abstract void primitiveOperation1();

    abstract void primitiveOperation2();

    void concreteOperation() {
        //这里是实现
    }

    /**
     *这是一个具体的方法，但他什么都不做
     * 我们也可以有“默认不做事的方法”，我们称这种方法为“hook”(钩子）。
     * 子类可以视情况决定要不要覆盖它们。
     */
    void hook() {

    }
}

8.5 对模板方法进行挂钩

钩子是一种被声明在抽象类中的方法,但只有空的或者默认的实现。钩子的存在,可以让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类自行决定。
钩子有好几种用途，让我们先看其中一个，稍后再看其他几个:

public abstract class CaffeinBeverageWithHook {
    void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        /**
         * 我们加上了一个的条件语句，而该条件是否成立，是由一个具体方法
         * customWantsCondiments决定的。如果顾客“想要”调料，只有这时我们才调用
         * addCondiments
         */
        if (customWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void brew();

    abstract void addCondiments();

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

    void pourInCup() {
        System.out.println("将饮料倒入杯子中");
    }

    /**
     * 我们在这里定义了一个方法，通常是空的缺省实现。这个方法只会返回true，不做别的事
     * 这就是一个钩子，子类可以覆盖这个，但不见得一定要去覆盖
     *
     * @return
     */
    boolean customWantsCondiments() {
        return true;
    }
}

8.6 使用钩子

为了测试钩子，我们在子类中覆盖它。钩子的作用是咖啡因饮料是否执行了某部分算法，说的更明确一些，就是饮料中是否要加进调料。

public class CoffeeWithHook extends CaffeinBeverageWithHook {
    @Override
    void brew() {
        System.out.println("将咖啡粉放入沸水中");
    }

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

    /**
     * 让用户输入他们对调料的决定，根据用户的输入返回true或false
     *
     * @return
     */
    @Override
    public boolean customWantsCondiments() {
        String answer = getUserInput();
        if (answer.toLowerCase().startsWith("y")) {
            return true;
        } else {
            return false;
        }
    }

    private String getUserInput() {
        String answer = null;
        System.out.println("您需要咖啡里面加糖和牛奶吗？");
        InputStream in;
        BufferedReader inputt = new BufferedReader(new InputStreamReader(System.in));
        try {
            answer = inputt.readLine();
        } catch (IOException ioe) {
            System.out.println("IO error tring to read your answer");
        }
        if (answer == null) {
            return "no";
        }
        return answer;
    }
}

自己尝试一下模仿着CoffeeWithHook将TeaWithHook写出来
接下来我们开始进行测试

public class BeverageTestDriver {
    public static void main(String[] args) {
        TeaWithHook teaHook = new TeaWithHook();//创建一杯茶
        CoffeeWithHook coffeeHook = new CoffeeWithHook();//创建一杯咖啡
        System.out.println("开始制茶");
        teaHook.prepareRecipe();
        System.out.println("开始制作咖啡");
        coffeeHook.prepareRecipe();
    }
}

学到此处，我们可能会有些疑问

• 1.在使用模板方法时,怎么才能知道什么时候该使用抽象方法,什么时候使用钩子呢?

答:当你的子类“必须”提供算法中某个方法或步骤的实现时,就使用抽象方法。如果算法的这个部分是可选的，就用钩子。如果是钩子的话,子类可以选择实现这个钩子，但并不强制这么做。

• 2.子类必须实现抽象类中的所有方法吗？

答:是的，每一个具体的子类都必须定义所有的抽象方法,并为模板方法算法中未定义步骤提供完整的实现。

• 3.似平我应该保持抽象方法的数目越少越好,否则,在子类中实现这些方法将会很麻烦?

答:当你在写模板方法的时候,心里要随时记得这一点。想要做到这一点,可以让算法内的步骤不要切割得太细,但是如果步骤太少的话,会比较没有弹性,所以要看情况折衷。也请记住,某些步骤是可选的,所以你可以将这些步骤实现成钩子,而不是实现成抽象方法这样就可以让抽象类的子类的负荷减轻。

8.7 好莱坞原则

好莱坞原则可以给我们一种防止“依赖腐败”的方法。当高层组件依赖低层组件,而低层组件又依赖高层组件,而高层组件又依赖边侧组件,而边侧组件又依赖低层组件时，依赖腐败就发生了。在这种情况下，没有人可以轻易地搞懂系统是如何设计的。
在好菜坞原则之下，我们允许低层组件将自己挂钩到系统上，但是高层组件会决定什么时候和怎样使用这些低层组件。换句话说，高层组件对待低层组件的方式是“别调用我们，我们会调用你”

好莱坞原则和模板方法

好菜坞原则和模板方法之间的连接其实还算明显:当我们设计模板方法模式时，我们告诉子类，“不要调用我们，我们会调用你”。怎样才能办到呢?让我们再看一次咖啡因饮料的设计:

• 1.好莱坞原则和依赖倒置原则之间的关系如何?

答:依赖倒置原则教我们尽量避免使用具体类，而多使用抽象。而好莱坞原则是用在创建框架或组件上的一种技巧，好让低层组件能够被挂钩进计算中，而且又不会让高层组件依赖低层组件。两者的目标都是在于解耦,但是依赖倒置原则更加注重如何在设计中避免依赖。
好莱坞原则教我们一个技巧,创建一个有弹性的设计,允许低层结构能够互相操作,而又防止其他类太过依赖它们。

• 2.低层组件不可以调用高层组件中的方法吗?

答:并不尽然。事实上,低层组件在结束时，常常会调用从超类中继承来的方法。我们所要做的是,避免让高层和低层组件之间有明显的环状依赖。

8.8 用模板方法排序

Java数组类的设计者提供给我们一个方便的模板方法用来排序。让我们看看这个方法如何运行:

public class SortUtils {
    /**
     * 第一个方法sort()只是一个辅助(helper)方法、用来创建一个数组的拷贝，然后将其传
     * 递给mergeSort()方法当作目标数组。同时传入mergeSort()的参数，还包括数组的长度、以及从
     * (0)开始排序。
     *
     * @param a
     */
    public static void sort(Object[] a) {
        Object aux[] = (Object[]) a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

    /**
     * mergeeSort()方法包含排序算，此算法依赖于compareTo()方法实现
     *
     * @param src
     * @param dest
     * @param low
     * @param high
     * @param off
     */
    private static void mergeSort(Object[] src, Object dest[], int low, int high, int off) {//此处可以看成是一个模板方法
        for (int i = low; i < high; i++) {
            for (int j = i; j > low && ((Comparable) dest[j - 1]).compareTo((Comparable) dest[j]) > 0; j--) {
                swap(dest, j, j - 1);
            }
        }
        return;
    }

    /**
     * 交换i,j的值
     *
     * @param src
     * @param i
     * @param j
     */
    private static void swap(Object[] src, int i, int j) {
        Object temp = src[i];
        src[i] = src[j];
        src[j] = temp;
    }

}

8.9 排序鸭子

假如我们有一个鸭子的数组需要排序，你要怎么做？
数组的排序模板方法已经提供了算法,但是你必须让这个模板方法知道如何比较鸭子。
而sort()的设计者希望这个方法能使用于所有的数组，所以他们把sort()变成是静态的方法,这样一来，任何数组都可以使用这个方法。但是没关系，它使用起来和它被定义在超类中是一样的。
现在,还有一个细节要告诉你:因为sort()并不是真正定义在超类中,所以sort()方法需要知道你已经实现了这个compareTo方法,否则就无法进行排序。
要达到这一点,设计者利用了Comparable接口。你须实现这个接口，提供这个接口所声明的方法,也就是compareTo()。

什么是compareTo()?

这个compareTo()方法将比较两个对象，然后返回其中一个是大于、等于还是小于另一个。sort()只要能够知道两个对象的大小,当然就可以进行排序。

比较鸭子

好了，现在你知道了如果要排序鸭子，就必须实现这个compareTo()方法:然后,数组就可以被正常地排序了。
鸭子的实现如下：

/**
 * 我们之所以需要让鸭子类实现Compareable接口，因为我们无法真的让鸭子数组去继承数组。
 */
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 + " 重量:" + weight;
    }

    /**
     * compareTo需要被传入另-鸭子。和本身这只鸭子做比较。
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        Duck otherDuck = (Duck) o;
        if (this.weight < otherDuck.weight) {
            return -1;
        } else if (this.weight == otherDuck.weight) {
            return 0;
        } else {
            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("未排序时的鸭子数组：");
        display(ducks);
        System.out.println("排序之后的鸭子数组：");
        Arrays.sort(ducks);
        display(ducks);
    }

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

运行结果如下：

下面我们分析一下鸭子排序的内部是怎么实现的

• 1.首先我们需要一个鸭子数组

     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)
        };

• 2.然后调用Array类的sort()模板方法，并传入鸭子数组

Arrays.sort(ducks);

这个sort()方法控制排序过程

• 3.想要排序一个数组，你需要一次又一次地比较两个对象，直到整个数组都排序完毕。
  当比较两只鸭子的时候,排序方法需要依赖鸭子的compareTo()方法，以得知谁大谁小。第一只鸭子的compareTo()方法被调用，并传入另一只鸭子当成比较对象:

ducks[0].compareTo(ducks[1])

• 4.如果鸭子的次序不对，就用Array的具体swap0方法将两者对调:

swap();

• 5.排序方法会持续比较并对调鸭子,直到整个数组的次序是正确的!

看到此处你可能会认为我是想象力太丰富，这些和模板方法有什么联系

这个模式的重点在于提供一个算法,并让子类实现某些步骤而数组的排序做法很明显地并非此如此
但是，我们都知道,荒野中的模式并非总是如同教科书例子一般地中规中矩。为了符合当前的环境和实理的约束,它们总是要被适当地修改。
这个Array 类sort()方法的设计者受到一些约束。
通常我们无法设计一个类继承java数组，而sort()方法希望能够适用于所有的数组（每个数组都是不同的类）。所以它们定义了一个静态方法,而由被排序的对象内的每个元素自行提供比较大小的算法部分。所以,这虽然不是教科书上的模板方法,但它的实现仍然符合模板方法模式的精神。再者,由于不需要继承数组就可以使用这个算法,这样使得排序变得更有弹性、更有用。

在Java API中还有其他模板方法的例子吗？

答:是的，你可以在一些地方看到它们。比方说，java.io的InputStream类有一个read()方法,是由子类实现的、而这个方法又会被read(byte b[], int off,int len)模板方法使用。

接下来我们继续丰富我们的OO原则
封装变化
多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之问的松耦合设计而努力
类应该对扩展开放，对修改关闭
依赖抽象，不要依赖具体类
只和朋友交谈
别找我，我会找你

下一篇 《设计模式09—迭代器与组合模式》