8、Template Method 模板方法

模板方法模式是在日常开发中使用最为广泛的设计模式之一。

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

类图

代码实例

某日，程序员A拿到一个任务：给定一个整数数组，把数组中的数由小到大排序，然后把排序之后的结果打印出来。经过分析之后，这个任务大体上可分为两部分，排序和打印，打印功能好实现，排序就有点麻烦了。但是A有办法，先把打印功能完成，排序功能另找人做。

	abstract class AbstractSort {  
	      
	    /** 
	     * 将数组array由小到大排序 
	     * @param array 
	     */  
         protected abstract void sort(int[] array);  
	      
	    public void showSortResult(int[] array){  
	        this.sort(array);  
	        System.out.print("排序结果：");  
	        for (int i = 0; i < array.length; i++){  
	            System.out.printf("%3s", array[i]);  
	        }  
	    }  
	}  

写完后，A找到刚毕业入职不久的同事B说：有个任务，主要逻辑我已经写好了，你把剩下的逻辑实现一下吧。于是把AbstractSort类给B，让B写实现。B拿过来一看，太简单了，10分钟搞定，代码如下：

1.	class ConcreteSort extends AbstractSort {  
2.	  
3.	    @Override  
4.	    protected void sort(int[] array){  
5.	        for(int i=0; i<array.length-1; i++){  
6.	            selectSort(array, i);  
7.	        }  
8.	    }  
9.	      
10.	    private void selectSort(int[] array, int index) {  
11.	        int MinValue = 32767; // 最小值变量  
12.	        int indexMin = 0; // 最小值索引变量  
13.	        int Temp; // 暂存变量  
14.	        for (int i = index; i < array.length; i++) {  
15.	            if (array[i] < MinValue){ // 找到最小值  
16.	                MinValue = array[i]; // 储存最小值  
17.	                indexMin = i;   
18.	            }  
19.	        }  
20.	        Temp = array[index]; // 交换两数值  
21.	        array[index] = array[indexMin];  
22.	        array[indexMin] = Temp;  
23.	    }  
24.	}  

写好后交给A，A拿来一运行：

1.	public class Client {  
2.	    public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组  
3.	    public static void main(String[] args){  
4.	        AbstractSort s = new ConcreteSort();  
5.	        s.showSortResult(a);  
6.	    }  
7.	}

模版方法模式的结构

模版方法模式由一个抽象类和一个（或一组）实现类通过继承结构组成，抽象类中的方法分为三种：

1. 抽象方法：父类中只声明但不加以实现，而是定义好规范，然后由它的子类去实现。
2. 模版方法：由抽象类声明并加以实现。一般来说，模版方法调用抽象方法来完成主要的逻辑功能，并且，模版方法大多会定义为final类型，指明主要的逻辑功能在子类中不能被重写。
3. 钩子方法：由抽象类声明并加以实现。但是子类可以去扩展，子类可以通过扩展钩子方法来影响模版方法的逻辑。

public abstract class HummerModel {
    protected abstract void start(); //发动
    protected abstract void stop();  //停止
    protected abstract void alarm(); //鸣笛
    protected abstract void engineBoom(); //轰鸣
    final public void run() { //车总归要跑
        this.start();
        this.engineBoom();
        if(this.isAlarm()) {//想让它叫就叫，不想就不叫（钩子方法）        
            this.alarm();
        }
        this.stop();
    }
    protected boolean isAlarm() { //我们加了一个判断方法，默认返回true
        return true;
    }
}

抽象类的任务是搭建逻辑的框架，通常由经验丰富的人员编写，因为抽象类的好坏直接决定了程序是否稳定性。

实现类用来实现细节。抽象类中的模版方法正是通过实现类扩展的方法来完成业务逻辑。只要实现类中的扩展方法通过了单元测试，在模版方法正确的前提下，整体功能一般不会出现大的错误。

在使用这种模式的时候我们要注意几点：

1. 保护抽象类中定义算法顺序的方法不被子类修改。

2. 分离可变及不可变部分，让子类自己决定可变部分的实现。

3. 让算法的具体实现对子类开放，对其他类关闭。

模版方法的优点及适用场景

1.  容易扩展。一般来说，抽象类中的模版方法是不易反生改变的部分，而抽象方法是容易反生变化的部分，因此通过增加实现类一般可以很容易实现功能的扩展，符合开闭原则。
2.  便于维护。对于模版方法模式来说，正是由于他们的主要逻辑相同，才使用了模版方法，假如不使用模版方法，任由这些相同的代码散乱的分布在不同的类中，维护起来是非常不方便的。
3.  比较灵活。因为有钩子方法，因此，子类的实现也可以影响父类中主逻辑的运行。但是，在灵活的同时，由于子类影响到了父类，违反了里氏替换原则，也会给程序带来风险。这就对抽象类的设计有了更高的要求。
4.  在多个子类拥有相同的方法，并且这些方法逻辑相同时，可以考虑使用模版方法模式。在程序的主框架相同，细节不同的场合下，也比较适合使用这种模式。