模板方法模式是类的行为模式。
准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，
然后声明一些抽象方法迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，
从而对剩余的逻辑有不同的实现。这就是模板方法的用意。
模板方法模式的结构
这里涉及两个角色：
抽象模板角色（Abstract Template）由如下责任：
- 定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤。
- 定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体的方法。
具体模板角色(Concrete Template)的责任：
- 实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤。
- 每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级路基的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。
源代码：
抽象模板类
public abstract class AbstractClass { public void TemplateMethod(){ //调用基本方法（由子类实现） doOperation1(); doOperation2(); doOperation3(); } //基本方法的声明 protected abstract void doOperation1(); protected abstract void doOperation2(); private final void doOperation3(){ //do something } }
具体模板类
public class ConcreteClass extends AbstractClass { @Override protected void doOperation1() { // TODO Auto-generated method stub System.out.println("doOperation1"); } @Override protected void doOperation2() { // TODO Auto-generated method stub System.out.println("doOperation2"); } }
这个具体类实现了 父类声明的基本方法 - doOperation1()和doOperation2() ，而这两个基本方法所代表的就是强制子类实现的剩余逻辑。
好莱坞原则体现了模板模式的关键：
子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。
一个例子
考虑一个计算存款利息的例子。
抽象类Account
public abstract class Account { protected String accountNumber; /** * 默认构造函数 */ public Account(){ accountNumber = null; } /** * 构造函数 * @param accountNumber */ public Account(String accountNumber){ this.accountNumber = accountNumber; } /** * 模板方法，计算利息数额 * @return */ final public double calculateInterest() { double interestRate = doCalculateInterestRate(); String accountType = doCalculateAccountType(); double amount = calculateAmount(accountType,accountNumber); return amount*interestRate; } abstract protected String doCalculateAccountType(); abstract protected double doCalculateInterestRate(); /** * 基本方法，已经实现 * @param accountType * @param accountNumber * @return */ final public double calculateAmount(String accountType,String accountNumber){ // retrieve amount from database... return 7243.00D; } }
具体子类MoneyMarketAccount
public class MoneyMarketAccount extends Account { /** * 基本方法在这里实现 */ @Override protected String doCalculateAccountType() { // TODO Auto-generated method stub return "Money Market"; } /** * 基本方法在这里实现 */ @Override protected double doCalculateInterestRate() { // TODO Auto-generated method stub return 0.045D; } }
具体子类CDAccount
public class CDAccount extends Account { /** * 基本方法在这里实现 */ @Override protected String doCalculateAccountType() { // TODO Auto-generated method stub return "Certificate of Deposite"; } /** * 基本方法在这里实现 */ @Override protected double doCalculateInterestRate() { // TODO Auto-generated method stub return 0.065D; } }
客户端
public class Client { private static Account acct = null; public static void main(String[] args) { acct = new MoneyMarketAccount(); System.out.println("Interest from Money Market account"+acct.calculateInterest()); acct = new CDAccount(); System.out.println("Interest from CD account"+acct.calculateInterest()); } }
Java语言里使用过的模板方法模式
HttpServlet技术
作为Java对Web系统的解决方案，HttpServlet技术时建立在模板方法模式的基础之上的。
HttpServlet类提供了一个service()方法。这个方法调用7个do方法中的一个或几个，
完成对客户端调用的处理。这些do方法则要由具体HttpServlet类提供。在这里，service()方法便是模板方法，
7个do方法便是基本方法。
模板方法模式中的方法
模板方法中方法可以分为两大类：模板方法（Template Method）和基本方法（Primitive Method）。
模板方法
一个模板方法总是定义在抽象类中的，把基本操作方法组合在一起形成一个总算法或一个总行为的方法。
这个模板方法一般会在抽象类中定义，并由子类不加修改的完全继承下来。
一个抽象类可以有任意多个模板方法，而不限于一个。每一个模板方法都可以调用任意多个具体方法。
基本方法
基本方法又可以分为三种：抽象方法（Abstract Method）、具体方法（Concrete Method）、和钩子方法（Hook Method）。
- 抽象方法：一个抽象方法由抽象类声明，由具体子类实现。
- 具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换。
- 钩子方法：一个钩子方法由抽象类声明并实现，而子类会加以扩展。通常抽象类给出一个空实现，作为方法的默认实现。
如何决定一个基本方法是哪一种
决定哪一个方法应作为具体方法是一个较为简单的任务，而决定哪一个方法作为抽象方法而不是钩子方法，
或者应作为钩子方法而不是抽象方法，则常常不是一个容易的任务。
模板方法模式的设计理念是尽量减少必须由子类置换掉（override）的基本方法的数目。
命名规则
钩子方法的名字应当以do开始。
重构的原则
在对一个继承的等级结构做重构时，一个应当遵从的原则便是将行为尽量移动到结构的高端，而将状态尽量移动到结构的低端。
1995年，Auer曾在文献中指出：
1. 应当根据行为而不是状态定义一个类。
2. 在实现行为时，是用抽象状态而不是用具体状态。
3. 给操作划分层次。一个类的行为应当放到一个小组核心方法里面，这些方法可以很方便的在子类中加以置换。
4. 将状态属性的确认推迟到子类中。不要在抽象类中过早的声明属性变量，应将它们尽量的推迟到子类中去声明。