9 Template Method Pattern（模板方法模式）
前言：封装步骤的算法。
Vander作为老板，凡是亲力亲为，他新开了家咖啡店，这是他招牌咖啡卡布奇诺的冲泡方法：
1、把水煮沸
2、用沸水冲泡咖啡
3、将咖啡倒入咖啡杯
4、加糖和奶
Vander发现白天喝咖啡的人实在是不多，白天的生意很差，白天大家都喜欢喝奶茶，特别是夏天到了，冰凉的奶茶更受欢迎，于是Vander开始研制它的柠檬奶茶。以下是柠檬奶茶的制作方法：
1、把水煮沸
2、用沸水泡茶叶
3、将茶倒入茶杯中
4、加柠檬和奶
Vander如行云流水般写完了这两个制作方法。
咖啡：
public class Coffee {
void prepareRecipe() {
boilWater();
brewCoffeeGrinds();
pourInCup();
addSugarAndMilk();
}
public void boilWater() {
System.out.println("Boiling water");
}
public void brewCoffeeGrinds() {
System.out.println("Dripping Coffee throught filter");
}
public void pourInCup() {
System.out.println("Pouring into cup");
}
public void addSugarAndMilk() {
System.out.println("Adding sugar and milk");
}
}
奶茶：
public class MilkTea {
void prepareRecipe() {
boilWater();
steepTeaBag();
pourInCup();
addTeaAndMilk();
}
public void boilWater() {
System.out.println("Boiling water");
}
public void pourInCup() {
System.out.println("Pouring into cup");
}
public void steepTeaBag() {
System.out.println("Steeping the tea");
}
public void addTeaAndMilk() {
System.out.println("Adding tea and milk");
}
}
他自认为写得很漂亮，请来了Panda大师一起来鉴赏，Panda大师一看，这个实现有太多冗余代码了，首先奶茶跟咖啡制作流程既然是相似的，为什么不做成一个Beverage抽象类，让它们来继承呢，在抽象类中将prepareRecipe方法固定下来，这样后面的制作的饮料都要遵循这个流程了，接下来煮水和将饮料倒入杯中实际上也是一样的，也能在抽象的父类Beverage中实现，steep（浸泡）和brew（冲泡）实际上也没多大区别，所以给个新名字brew，最后加入糖和奶跟加入柠檬和奶，也是类似的，也给个新名字addCondiments。改造完之后类图如下：
Vander仔细琢磨了Panda大师的做法，发现Panda大师实际上先做了泛化（将实现泛化成抽象通用），接着再将一些具体的步骤交给子类来完成。Vander想了想其实prepareRecipe完全可以定义成final。这样就把这个传统的做法定义下来，不允许子类擅自修改流程。
Panda大师一看，不错，你终于学到精髓了，实际上我们刚刚的做法就是用了模板方法模式。Panda来总结一下模板方法模式的好处：
1、抽象父类中定义了算法（也就是饮料制作流程），保护了算法。
2、对于子类来说，抽象父类的存在将代码的复用最大化。
3、算法只存在于一个地方，方便修改。
4、模板方法提供了一个框架，可以让其他饮料插进来，新的饮料只要实现自己的方法就行了。
5、抽象父类专注于方法本身，而由子类提供完整的实现。
Panda大师指导改造后，代码成这样：
Beverage：
public abstract class Beverage {
public final void prepareRecipe() {
boilWater();
brew();
pourInCup();
addCondiments();
}
public void boilWater() {
System.out.println("Boiling water");
}
abstract void brew();
public void pourInCup() {
System.out.println("Pouring into cup");
}
abstract void addCondiments();
}
coffee：
public class Coffee extends Beverage {
@Override
public void brew() {
System.out.println("Dripping Coffee throught filter");
}
@Override
void addCondiments() {
System.out.println("Adding sugar and milk");
}
}
Milktea:
public class Milktea extends Beverage {
public void brew() {
System.out.println("Steeping the tea");
}
public void addCondiments() {
System.out.println("Adding tea and milk");
}
}
说了那么多，模板方法模式具体是什么呢？
模板方法模式:在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
实际上这个模式是用来创建一个算法的模板。什么是模板呢，实际上模板就是一个方法，更具体地说，这个方法将算法定义成一组步骤，其中任何步骤都可以是抽象的，由子类负责实现。这可以确保算法的结构保持不变，同时由子类提供部分实现。
下面是模板方法模式常用的套路：
这里需要说明的是，抽象类中有个钩子方法，这个钩子方法是在抽象类中提供了一个简单的实现，子类可以选择去覆盖它重新实现，也可以使用父类的实现。
有了Panda大师度身定制咖啡和奶茶之后，添加其他饮料更加方便了，很快就加入了蔬菜汁等饮料。但是有些客人不喜欢喝带奶的卡布奇诺，他喜欢喝纯咖啡。Vander想了想，能不能让客户告诉我要不要加奶和糖，我在制作的时候就可以按照客户的请求来完成了，实际上这是任何一个奶茶店和咖啡店都需要有的基本功能。Vander是这么改造的：
饮料父类：
public abstract class Beverage {
public final void prepareRecipe() {
boilWater();
brew();
pourInCup();
if(customCondiments()) {
addCondiments();
}
}
public void boilWater() {
System.out.println("Boiling water");
}
abstract void brew();
public void pourInCup() {
System.out.println("Pouring into cup");
}
abstract void addCondiments();
public boolean customCondiments() {
return true;
}
}
咖啡类：
public class Coffee extends Beverage {
@Override
public void brew() {
System.out.println("Dripping Coffee throught filter");
}
@Override
void addCondiments() {
System.out.println("Adding sugar and milk");
}
public boolean customCondiments() {
String answer = getUserInput();
if(answer.toLowerCase().startsWith("y")) {
return true;
} else {
return false;
}
}
private String getUserInput() {
String answer = null;
System.out.println("would you like some milk and sugar with your coffee (y/n)? ");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
try {
answer = bufferedReader.readLine();
} catch (IOException e) {
System.err.println("IO error trying to read your answer");
}
if(answer == null) {
return "no";
}
return answer;
}
}
奶茶类：
public class MilkTea extends Beverage {
public void brew() {
System.out.println("Steeping the tea");
}
public void addCondiments() {
System.out.println("Adding sugar and milk");
}
public boolean customCondiments() {
String answer = getUserInput();
if(answer.toLowerCase().startsWith("y")) {
return true;
} else {
return false;
}
}
private String getUserInput() {
String answer = null;
System.out.println("would you like some milk and sugar with your tea (y/n)? ");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
try {
answer = bufferedReader.readLine();
} catch (IOException e) {
System.err.println("IO error trying to read your answer");
}
if(answer == null) {
return "no";
}
return answer;
}
}
实现的效果：
下面再说明一下钩子算法的目的：
1、让子类实现算法中的可选部分
2、能够让子类有机会对模板方法中某些即将发生的步骤作出反应（如在上面的咖啡类中，完全可以让父类来询问是否加入佐料，而子类再进行加入佐料后的一些附加操作）。
还要注意的是，在写模板方法时，不要将算法的步骤切割得太细（子类要实现太多操作），也不要步骤太少（会没有弹性），所以要看情况折衷。步骤可选的时候就使用钩子方法。
模板方法模式跟一个设计原则很吻合，这个设计原则就是好莱坞原则——别调用（打电话给）我们，我们会调用（打电话给）你。好莱坞原则可以防止“依赖腐败”，什么是依赖腐败呢，当高层组件依赖底层组件，而底层组件又依赖高层组件，而高层组件又依赖边侧组件，边侧组件还依赖于底层组件的时候依赖腐败就发生了，这种情况很难搞清楚系统是如何设计的。我们允许底层组件将自己挂钩到系统上，但是高层组件会决定什么时候和如何使用这些组件。换句话说：高层组件对待底层组建的方式就是“别调用我们，我们会调用你”。实际上不只是模板方法模式，工厂模式和观察者模式也采用了好莱坞原则。
好莱坞原则 VS 依赖倒置原则
先对比一下策略模式和模板方法模式：
策略模式：将算法定义成对象，其他对象通过委托的方式来让这些算法用起来。
模板方法模式：定义算法的一个大纲，算法中的个别步骤可以有不同的实现细节，会重复使用的代码可以放进超类中，好让所有的子类共享。
模板方法模式 VS 策略模式 VS 工厂方法模式
| 模式 | 叙述 |
|---|---|
| 模板方法 | 子类决定如何实现算法中的步骤 |
| 策略 | 封装可互换的行为，然后使用委托来决定要采用哪一个行为 |
| 工厂方法 | 由子类决定实例化哪个具体类 |
下面我们要进入Java中的模板方法，模板方法并非刚刚举的例子那样明显，有些隐藏得颇深，让我们来细细挖掘。
Java数组类的设计者给出了一个排序的算法，但是排序的方法中compareTo方法却是需要我们自身实现的，因为设计者无法知道你想按照什么东西来进行排序，你必须告诉这个排序算法你依照什么来进行排序的。
接下来看看Sun的源码：
Comparable接口：
public interface Comparable<T> {
public int compareTo(T o);
}
Arrays的相关函数：
public static void sort(Object[] a) {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a);
else
ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a) {
Object[] aux = a.clone();
mergeSort(aux, a, 0, a.length, 0);
} 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;
}
// Recursively sort halves of dest into src
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);
// If list is already sorted, just copy from src to dest. This is an
// optimization that results in faster sorts for nearly ordered lists.
if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
/**
* Swaps x[a] with x[b].
*/
private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
具体的排序细节见博客中数据结构的MergeSort，这里关注的是Arrays的Sort方法会调用数组的compareTo来进行比较，比较之后再进行位置的对调，这实际上就是让子类数组来实现具体的算法细节（即比较），而父类数组完成算法的步骤（即排序）。
另外，sort()模板方法实现不使用继承，sort方法被定义成一个静态的方法，在运行时和Comparable组合，如果类不实现Comparable接口的话就会导致sort方法中类型转换失败。
下面再看一个模板方法的实例JFrame，里面的paint方法是一个钩子方法，默认情况下是不做事情的，要是你继承了JFrame并且实现了paint方法，它就会进行相应的操作。
MyFrame类：
public class MyFrame extends JFrame {
public MyFrame(String title) {
super(title);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(300, 300);
this.setVisible(true);
}
public void paint(Graphics graphics) {
super.paint(graphics);
String msg = "09-Template-Method-Pattern";
graphics.drawString(msg, 80, 150);
}
}
Main：
public class Main {
public static void main(String args[]) {
MyFrame frame = new MyFrame("Design Pattern");
}
}
我们查看堆栈信息发现，paint方法也相当于作为一个步骤被其它算法调用。
模板方法定义了算法的步骤，把这些步骤实现延迟到了子类，它是一种代码复用的技巧。
好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用低层模块。
策略模式和模板方法模式都封装算法，一个用组合，一个用继承。工厂方法是模板方法的一种特殊版本。
最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。
面向对象基础
抽象、封装、多态、继承
八大设计原则
设计原则一：封装变化
设计原则二：针对接口编程，不针对实现编程
设计原则三：多用组合，少用继承
设计原则四：为交互对象之间的松耦合设计而努力
设计原则五：对扩展开放，对修改关闭
设计原则六：依赖抽象，不要依赖于具体的类
设计原则七：只和你的密友谈话
设计原则八：别找我，我有需要会找你
模式
**模板方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。 ****
