设计模式~模板方法模式

模板方法模式是类的行为模式。

准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，

然后声明一些抽象方法迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，

从而对剩余的逻辑有不同的实现。这就是模板方法的用意。

模板方法模式的结构

 

 这里涉及两个角色：

抽象模板角色（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. 将状态属性的确认推迟到子类中。不要在抽象类中过早的声明属性变量，应将它们尽量的推迟到子类中去声明。