模版方法模式

一.前言

what is templatemethod,一句话我的理解：
在超类并定义了算法的步骤，定义了共有步骤的具体实现，并允许子类为一个或者多个步骤提供实现。
解释：比如在超类中定义算法步骤包括5步，其中1、3、5是在超类中实现的，2、4的实现在子类中有不同，所以子类各自实现。

二.简单的例子

泡茶和冲咖啡，他们的步骤分别是:
泡茶：
1.把水煮沸
2.用沸水浸泡茶叶
3.把茶水倒进杯子
4.加柠檬
冲咖啡：
1.把水煮沸
2.用沸水冲泡咖啡
3.把咖啡倒进杯子

4.加糖和牛奶

对应的代码如下:

public class Tea {
 
	void prepareRecipe() {
		boilWater();
		steepTeaBag();
		pourInCup();
		addLemon();
	}
 
	public void boilWater() {
		System.out.println("Boiling water");
	}
 
	public void steepTeaBag() {
		System.out.println("Steeping the tea");
	}
 
	public void addLemon() {
		System.out.println("Adding Lemon");
	}
 
	public void pourInCup() {
		System.out.println("Pouring into cup");
	}
}

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 through filter");
	}
 
	public void pourInCup() {
		System.out.println("Pouring into cup");
	}
 
	public void addSugarAndMilk() {
		System.out.println("Adding Sugar and Milk");
	}
}

很明显，这两个类是存在了重复代码的，既然他们步骤是类似的，应该将共同的部分抽取出来，放入一个基类中。我们不难得出下面的关系：

饮料超类:

public abstract class Beverage {
  
	final void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		addCondiments();
	}
 
	abstract void brew();
  
	abstract void addCondiments();
 
	void boilWater() {
		System.out.println("Boiling water");
	}
  
	void pourInCup() {
		System.out.println("Pouring into cup");
	}
}

茶：

public class Tea extends Beverage {
	public void brew() {
		System.out.println("Steeping the tea");
	}
	public void addCondiments() {
		System.out.println("Adding Lemon");
	}
}

咖啡：

public class Coffee extends Beverage {
	public void brew() {
		System.out.println("Dripping Coffee through filter");
	}
	public void addCondiments() {
		System.out.println("Adding Sugar and Milk");
	}
}

想到有个问题，像我们家妹纸，喝东西都喜欢原味的，我这强制加了Condiment好像不好诶，肿么办，为了我们家妹纸，当然不能提供这么愚蠢的设计，有办法的，我们使用钩子，改造上述代码改造如下：

public abstract class BeverageWithHook {
 
	void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		//在这里控制是否执行addCondiments
		if (customerWantsCondiments()) {
			addCondiments();
		}
	}
 
	abstract void brew();
 
	abstract void addCondiments();
 
	void boilWater() {
		System.out.println("Boiling water");
	}
 
	void pourInCup() {
		System.out.println("Pouring into cup");
	}
	
	//默认为都需要加调味料
	boolean customerWantsCondiments() {
		return true;
	}
}

//拥有钩子的茶
public class TeaWithHook extends BeverageWithHook {
 
	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() {
		// get the user's response
		String answer = null;

		System.out.print("Would you like lemon with your tea (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 CoffeeWithHook extends BeverageWithHook {
 
	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;
	}
}

上述的钩子控制了是否向饮料中加入调味料。总结一下上面的思路：
当子类必须提供算法中某个方法或者步骤的实现时，就使用抽象方法。如果这个算法是可选的，就使用钩子，子类也可以覆盖钩子，但不强制这么做。

一个好玩的原则，好莱坞原则：

别打电话给我，我会打电话给你。
翻译一下就是：
别调用我们，我们会调用你。
在模版方法中，就是基类调用了子类的方法。

三.排序方法对于模版方法的运用

java的数组类提供了一个模版的排序方法sort，源码如下:

public static void sort(Object[] a){
	Object aux[] = (Object [])a.clone();
	mergeSort(aux,a,0,a.length,0);
}

private static void mergeSort(Object src[],Object dest[],int low,int high,int off){
	for(int i=low;i<high;int off){
		for(int j=i;j>low&&((Comparable) dest[j-1]).compareTo((Comparable) dest[j])>0;j--){
			swap(dest,j,j-1);
		}
	}
}

从上面都代码可以看出，会调用数组中元素的compareTo方法，这个方法就需要在元素子类中实现这个方法，例如排序一个鸭子类：

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("\nAfter sorting:");
		display(ducks);
	}

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

这个跟模版方法虽然不能完全重合，但是基本思想是符合的：
1.鸭子数组
2.调用Array.sort
3.实现数组中鸭子的compareTo


自动脑补一下，以上。