模板方法模式是类的行为模式。准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的 方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。
UML类图
举例说明
比如我们做饭，我要煮面条。分为下面几个步骤
- 打开抽油烟机
- 生火
- 煮面条
- 关火
- 关闭油烟机
用代码实现
public class CookNoodles{
public void open() {
System.out.println("打开油烟机");
}
public void fire() {
System.out.println("生火");
}
public void doCook() {
System.out.println("煮面条");
}
public void outFire() {
System.out.println("关火");
}
public void close() {
System.out.println("关闭油烟机");
}
public void cook() {
this.open();
this.fire();
this.doCook();
this.outFire();
this.close();
}
}
执行
CookNoodles cook = new CookNoodles();
cook.cook();
但是我们不能只吃面条，还要炒个菜吃
public class CookVegetable {
public void open() {
System.out.println("打开油烟机");
}
public void fire() {
System.out.println("生火");
}
public void doCook() {
System.out.println("炒菜");
}
public void outFire() {
System.out.println("关火");
}
public void close() {
System.out.println("关闭油烟机");
}
public void cook() {
this.open();
this.fire();
this.doCook();
this.outFire();
this.close();
}
}
上面的两个类一比较，你会发现除了doCook()方法中的实现不一样，其他的方法步骤完全一样。身为渣渣程序猿的我看到很烦。我们可以将重复代码抽象出来，由父类实现它，然后煮面条和炒菜都继承于它
抽象类
public abstract class Cook {
public void open() {
System.out.println("打开油烟机");
}
public void fire() {
System.out.println("生火");
}
/**
* 子类去实现
*/
public abstract void doCook();
public void outFire() {
System.out.println("关火");
}
public void close() {
System.out.println("关闭油烟机");
}
/**
* 使用final关键字，防止子类重写
*/
public final void cook() {
this.open();
this.fire();
this.doCook();
this.outFire();
this.close();
}
}
炒菜和煮面条只要实现他们不同的那部分就可以了
public class CookNoodles extends Cook{
@Override
public void doCook() {
System.out.println("下面条");
}
}
public class CookVegetable extends Cook {
@Override
public void doCook() {
System.out.println("炒菜");
}
}
看到这里。你已经学会模板方法模式，使用场景为：当一个业务有N个步骤（模板），其中一部分是永恒不变的，那么将不变的步骤抽象到父类。可能变化的留给子类实现。
模板方法模式中的方法
先对代码进行注释区分下
public abstract class Cook {
public void open() {
System.out.println("打开油烟机");
}
public void fire() {
System.out.println("生火");
}
/**
* 基本方法的声明（子类去实现）
*/
public abstract void doCook();
/**
* 基本方法（空方法）
*/
public void doAfter() {}
/**
* 基本方法(已经实现)
*/
public void outFire() {
System.out.println("关火");
}
public void close() {
System.out.println("关闭油烟机");
}
/**
* 模板方法
*/
public final void cook() {
//调用基本方法
this.open();
this.fire();
this.doCook();
this.outFire();
this.close();
}
}
从上面类中可以看到，模板方法中的方法可以分为两大类：模板方法和基本方法。
模板方法
一个模板方法是定义在抽象类中的，把基本操作方法组合在一起形成一个总算法或一个总行为的方法
一个抽象类可以任意多个模板方法。而不受限于一个。
基本方法
基本方法分为三种：抽象方法（Abstract Method）、具体方法（Concrete Method） 和钩子方法（Hook Method）
- 抽象方法：一个抽象方法由抽象类声明。由具体子类实现。
- 具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换
- 钩子方法：一个钩子方法由抽象类声明并实现，而子类会加以扩展。通常抽象类给出实现是一个空方法。作为方法的默认实现。
命名规则
命名规则是设计师之间赖以沟通的管道之一，钩子方法的名字应该以do开始。
实际案例
servlet中的就是使用了典型的模板方法。使用过Servlet 需继承一个叫HttpServlet的抽象类。
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String method = req.getMethod();
long lastModified;
if (method.equals("GET")) {
lastModified = this.getLastModified(req);
if (lastModified == -1L) {
this.doGet(req, resp);
} else {
long ifModifiedSince = req.getDateHeader("If-Modified-Since");
if (ifModifiedSince < lastModified / 1000L * 1000L) {
this.maybeSetLastModified(resp, lastModified);
this.doGet(req, resp);
} else {
resp.setStatus(304);
}
}
} else if (method.equals("HEAD")) {
lastModified = this.getLastModified(req);
this.maybeSetLastModified(resp, lastModified);
this.doHead(req, resp);
} else if (method.equals("POST")) {
this.doPost(req, resp);
} else if (method.equals("PUT")) {
this.doPut(req, resp);
} else if (method.equals("DELETE")) {
this.doDelete(req, resp);
} else if (method.equals("OPTIONS")) {
this.doOptions(req, resp);
} else if (method.equals("TRACE")) {
this.doTrace(req, resp);
} else {
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[]{method};
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(501, errMsg);
}
}
HttpServlet类中方法
模板方法：service（）
基本方法：doPost()、doGet()等方法