模板方法模式（template）：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法的某些步骤。
通俗来讲：在父类的某个方法中定义了整个算法的骨架（就是这个调用各个方法的逻辑顺序），而将具体实现这一个算法的一些方法延迟到子类来实现（父类中仅有这个方法名，没有具体内容）。
模板方法模式结构图
喝咖啡和喝茶的例子
package com.template;
/**
* ClassName: AbstractClass
* @Description:抽象父类
* @author Panyk
* @date 2016年3月9日
*/
public abstract class AbstractClass {
/**
* @Description:封装的算法模块。
* 有了该算法模块，我们不需要调用细节方法，只需要调用该算法模块就能使用一系列的功能。
* （之所以是final为了防止子类重写该方法）
* @param
* @return void
* @throws
* @author Panyk
* @date 2016年3月9日
*/
final void templateMethod(){
this.boil();
this.brew();
this.pourIntoCup();
if(this.hook()){
this.addCondiments();
}
}
/**
* @Description:冲咖啡或者是泡茶
* @param
* @return void
* @throws
* @author Panyk
* @date 2016年3月9日
*/
abstract void brew();
/**
* @Description:添加调料
* @param
* @return void
* @throws
* @author Panyk
* @date 2016年3月9日
*/
abstract void addCondiments();
private void boil(){}{
System.out.println("烧开水！");
}
private void pourIntoCup(){
System.out.println("倒进杯子中！");
}
/**
* @Description:钩子方法，默认返回true，表示添加调料。
* @param @return
* @return boolean
* @throws
* @author Panyk
* @date 2016年3月9日
*/
protected boolean hook(){
return true;
}
}
package com.template;
public class Coffee extends AbstractClass {
/**
* 抽象方法子类必须实现
*/
@Override
protected void brew() {
System.out.println("冲咖啡！");
}
@Override
protected void addCondiments() {
System.out.println("添加糖和牛奶！");
}
@Override
protected boolean hook() {
System.out.println("钩子返回咖啡加调料！");
return true;
}
}
package com.template;
public class Tea extends AbstractClass {
@Override
void brew() {
System.out.println("泡茶！");
}
@Override
void addCondiments() {
System.out.println("添加柠檬！");
}
@Override
protected boolean hook() {
System.out.println("钩子返回喝茶不添加调料！");
return false;
}
}
package com.template;
public class People {
public void drink(){
AbstractClass c = new Coffee();
c.templateMethod();
System.out.println("-------------");
AbstractClass t = new Tea();
t.templateMethod();
}
public static void main(String[] args) {
People p = new People();
p.drink();
}
}
计算器的例子：
package com.template;
/**
* ClassName: AbstractCalculator
* @Description:模板方法模式（Template Method）：
* 解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，
* 也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。
* @author Panyk
* @date 2015年10月14日
*/
public abstract class AbstractCalculator {
//主方法，实现对本类的其它方法的调用
public final int calculate(String exp, String opt){
int[] array = split(exp, opt);
return this.calculate(array[0], array[1]);
}
public abstract int calculate(int num1, int num2);
private int[] split(String exp, String opt){
String[] arr = exp.split(opt);
int[] arrI = new int[2];
arrI[0] = Integer.parseInt(arr[0]);
arrI[1] = Integer.parseInt(arr[1]);
return arrI;
}
}
package com.template;
public class Plus extends AbstractCalculator {
@Override
public int calculate(int num1, int num2) {
return num1 + num2;
}
}
package com.template;
public class Main {
public static void main(String[] args) {
AbstractCalculator ac = new Plus();
int res = ac.calculate("3+5", "\\+");
System.out.println("3+5="+res);
}
}
