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

设计模式目录：

设计模式 1 ——观察者模式

设计模式 2 —— 装饰者模式 

设计模式 3 —— 迭代器和组合模式（迭代器）

设计模式 4 —— 迭代器和组合模式（组合）

设计模式 5 —— 工厂模式

设计模式 6 —— 单件模式

设计模式 7 —— 命令模式

设计模式 8 —— 适配器和外观模式

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

设计模式 10 —— 状态模式

概述

介绍

模板方法抽象类

模板方法的UML图

模板方法模式定义

JDK中模板方法模式的使用

Java API中的模板方法

参考

模板模式是一种行为设计模式，它的实现思路是，创建一个桩方法，并且定义一些步骤让子类来实现。模板方法定义了一个算法的执行步骤，或者说能够提供一种默认的实现，这种实现概括一部分子类或者全部子类的共同部分。

举一个例子帮助理解，假设提供一种造房子的算法。算法的步骤就是模拟造房子的过程：建地基、建支撑，最后添加墙和窗户 – 1. Fundation,2. Pillars,3. Walls,4. Windows。最重要的一点就是不能改变此建造过程，比如不可能在没用地基的时候就开始建造窗户。这个例子中，我们就创建了一个模板方法 – 将使用不同的方法完成对房子的建造。

为了确保子类不能重写(override)这个模板方法，应当使用final。

模板方法抽象类

因为设计为一些方法的具体实现留待子类中，所以不得不安排基类为一个抽象类

HouseTemple.java

package cn.telling.test.action;

/**
 * 
 * @ClassName: HouseTemplate TODO
 * @author xingle
 * @date 2015-9-24 下午2:04:22
 */
public abstract class HouseTemplate {
    // template method, final so subclasses can't override
    public final void buildHouse() {
        buildFoundation();
        buildPillars();
        buildWalls();
        buildWindows();
        System.out.println("House is built.");
    }

    // default implementation
    private void buildWindows() {
        System.out.println("Building Glass Windows");
    }

    // methods to be implemented by subclasses
    public abstract void buildWalls();

    public abstract void buildPillars();

    private void buildFoundation() {
        System.out.println("Building foundation with cement,iron rods and sand");
    }

}

buildHouse()是模板方法并定义了在建造房子过程中一系列方法的执行顺序。

WoodenHouse.java

package cn.telling.test.action;

/**
 * 
 * @ClassName: WoodenHouse
 * TODO
 * @author xingle
 * @date 2015-9-24 下午2:07:06
 */
public class WoodenHouse extends HouseTemplate{

    /**
     * 
     * @Description: TODO
     * @author xingle
     * @data 2015-9-24 下午2:07:15
     */
    @Override
    public void buildWalls() {
        System.out.println("Building Wooden Walls");
        
    }

    /**
     * 
     * @Description: TODO
     * @author xingle
     * @data 2015-9-24 下午2:07:15
     */
    @Override
    public void buildPillars() {
        System.out.println("Building Pillars with Wood coating");
    }

}

此处也应当对其他方法进行重写，但是为了简便，此处没用完成。

GlassHouse.java

package cn.telling.test.action;

/**
 * 
 * @ClassName: GlassHouse
 * TODO
 * @author xingle
 * @date 2015-9-24 下午2:05:28
 */
public class GlassHouse extends HouseTemplate{

    /**
     * 
     * @Description: TODO
     * @author xingle
     * @data 2015-9-24 下午2:05:39
     */
    @Override
    public void buildWalls() {
        System.out.println("Building Glass Walls");
    }

    /**
     * 
     * @Description: TODO
     * @author xingle
     * @data 2015-9-24 下午2:05:39
     */
    @Override
    public void buildPillars() {
        System.out.println("Building Pillars with glass coating");
        
    }

}

使用模板方法

用一个测试程序来测试此处已完成的模板方法。

HouseClient.java

package cn.telling.test.action;

/**
 * 
 * @ClassName: HousingClient TODO
 * @author xingle
 * @date 2015-9-24 下午2:06:33
 */
public class HousingClient {
    public static void main(String[] args) {

        HouseTemplate houseType = new WoodenHouse();

        // using template method
        houseType.buildHouse();
        System.out.println("************");

        houseType = new GlassHouse();

        houseType.buildHouse();
    }

}

注意，client正在调用基类的模板方法并且依赖于不同步骤的实现细节，即这些正在使用的方法，他们一些来着基类另一些来自子类。上述程序的输出：

模板方法的UML图

模板方法模式定义

模板方法模式定义一个操作中算法的骨架，而将这些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

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

JDK中模板方法模式的使用

• java.io.InputStream, java.io.OutputStream, java.io.Reader 以及 java.io.Writer 中所有非抽象方法。
• java.util.AbstractList, java.util.AbstractSet 以及 java.util.AbstractMap中所有非抽象方法。

重要提示

• 模板方法应该是由确定的步骤组成。这些步骤的顺序是固定的。基类与子类之间某些方法或者实现可以有所不同。模板方法应该是final的。
• 大多时候，子类的调用的方法是来自于超类。但是在模板模式中，超类的模板方法调用的方法却来至于子类，这就是著名的Hollywood原则-“don’t call us, we’ll call you”。
• 基类方法的默认实现被退化为钩子Hooks的概念，他们被设计在子类中被重写，如果你期望一些方法在子类中不被重写，你可以让他们为final。比如在例子中buildFoundation()方法是final的，因为不希望它在子类中被重写。

Java API中的模板方法

用模板方法排序

java数组类的设计者提供给我们一个方便的模板方法用来排序。

public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

其中 mergeSort() 方法包含排序算法，此算法依赖于compareTo() 方法的实现来完成算法。我们需要实现compareTo()方法，“填补”模板方法的缺憾。

/**
     * Src is the source array that starts at index 0
     * Dest is the (possibly larger) array destination with a possible offset
     * low is the index in dest to start sorting
     * high is the end index in dest to end sorting
     * off is the offset to generate corresponding low, high in src
     * To be removed in a future release.
     */
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

数组的排序模板方法已经提高了算法，但是你必须让这个模板方法知道如何比较鸭子。你所要做的事情就是，实现一个compareTo() 方法。

但是数组无法继承，该如何使用sort()？

sort() 的设计者希望这个方法能使用于所有的数组，所以他们把sort() 变成事静态的方法，这样一来，任何数组都可以使用这个方法。它使用起来和它被定义在超类中是一样的。实际上，sort()并不是真正定义在超类中，所以sort() 方法需要知道你已经实现了compareTo()方法，否则就无法进行排序。

要达到这一点，设计者利用了Comparable接口。你必须实现这个接口，提供这个接口所声明的方法，也就是compareTo()。

鸭子的实现：

package cn.telling.test.action;

/**
 * 
 * @ClassName: Duck
 * TODO
 * @author xingle
 * @date 2015-9-24 下午3:32:47
 */
public class Duck implements Comparable<Object>{
    //我们需要让鸭子类实现Comparable 接口，因为我们无法真的让鸭子数组去继承数组
    private String name ;
    private int weight;
    
    public Duck(String name,int weight){
        this.name = name;
        this.weight = weight;
    }
    
    public String toString(){
        return name+" weight"+weight;
    }

    /**
     * 排序所要的方法
     * @Description: TODO
     * @param o
     * @return
     * @author xingle
     * @data 2015-9-24 下午3:42:43
     */
    @Override
    public int compareTo(Object o) {
        //compareTo() 需要传入一只鸭子，和本身这种鸭子做比较
        Duck otherDuck = (Duck) o;
        if(this.weight<otherDuck.weight){
            return -1;
        } else if(this.weight == otherDuck.weight){
            return 0;            
        } else {
            return 1;
        }
    }
}

测试排序鸭子的程序：

package cn.telling.test.action;

import java.util.Arrays;

/**
 * 
 * @ClassName: DuckSortTestDrive
 * TODO
 * @author xingle
 * @date 2015-9-24 下午3:35:44
 */
public class DuckSortTestDrive {
    
    public static void main(String[] args) {
        Duck[] ducks = { new Duck("D1", 8), new Duck("D2", 6),
                new Duck("D3", 2),new Duck("D4", 5) };
        System.out.println("Bofore sorting  ");
        dispaly(ducks);
        //调用Array类的静态方法sort(),让后将鸭子数组当做参数传入
        Arrays.sort(ducks);
        System.out.println("After sorting  ");
        dispaly(ducks);
    }

    /**
     * TODO
     * @param ducks
     * @author xingle
     * @data 2015-9-24 下午3:39:17
     */
    public static void dispaly(Duck[] ducks) {
        for(int i = 0;i<ducks.length;i++){
            System.out.println(ducks[i]);
        }
        
    }

}

执行结果：

---

参考：

1. Java中的模板模式
2. [Head First设计模式]云南米线馆中的设计模式——模版方法模式
3. 《First Head 设计模式》 第8章 封装算法：模板方法模式