【java设计模式】模板方法模式（行为型模式）

理解

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

这样的例子在生活中还有很多，例如，一个人每天会起床、吃饭、做事、睡觉等，其中“做事”的内容每天可能不同。我们把这些规定了流程或格式的实例定义成模板，允许使用者根据自己的需求去更新它，例如，简历模板、论文模板、Word 中模板文件等。

以上文字转自：http://c.biancheng.net/view/1376.html

使用场景

• 多个子类有公有的方法，并且逻辑基本相同时

• 重要，复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现

• 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类，然后通过钩子函数约束其行为

结构

AbstractClass：其实就是一个抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体的方法。它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。

ConcreteClasses：ConcreteClass实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应，而每一个ConcreteClass都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

实例

AbstractClass

public abstract class AbstractClass {

    /**
     * 模板方法 根据需求按顺序调用
     */
    public void templateMethod() {
        SpecificMethod();
        abstractMethod1();
        abstractMethod2();
        if (hookMethod()) {
            SpecificMethod2();
        }
    }

    /**
     * 具体方法1
     * 抽象类中的具体方法做一些相同的工作
     */
    void SpecificMethod() {
        System.out.println("起床、刷牙、洗脸、吹个发型");
    }

    /**
     * 抽象方法 1
     * 抽象方法由子类实现，做一些不同的事情
     */
    abstract void abstractMethod1();

    /**
     * 抽象方法2
     * 抽象方法由子类实现，做一些不同的事情
     */
    abstract void abstractMethod2();

    /**
     * 钩子方法
     * 子类可以重写钩子方法，父类根据返回值来改变动作
     */
    boolean hookMethod() {
        return false;
    }

    /**
     * 具体方法2
     * 抽象类中的具体方法做一些相同的工作
     */
    void SpecificMethod2() {
        System.out.println("晚上和女朋友去开房了");
    }
}

ConcreteClass

public class ConcreteClassA extends AbstractClass{
    @Override
    void abstractMethod1() {
        System.out.println("去食堂吃饭，吃了豆浆、包子和油条");
    }

    @Override
    void abstractMethod2() {
        System.out.println("去运动，和小明一起打篮球");
    }

    /**
     * 重写钩子方法
     */
    boolean hookMethod() {
        // 是否有女朋友
        return false;
    }
}

public class ConcreteClassB extends AbstractClass{
    @Override
    void abstractMethod1() {
        System.out.println("吃饭选择点外卖，点了阿强酸菜鱼和一份米饭");
    }

    @Override
    void abstractMethod2() {
        System.out.println("去运动了，和女朋友小红一起打羽毛球");
    }

    /**
     * 重写钩子方法
     */
    boolean hookMethod() {
        // 是否有女朋友
        return true;
    }
}

Client

public class Client {
    public static void main(String[] args) {
        AbstractClass abstractClass;

        abstractClass = new ConcreteClassA();
        abstractClass.templateMethod();

        System.out.println("=============================");

        abstractClass = new ConcreteClassB();
        abstractClass.templateMethod();
    }
}

运行结果

起床、刷牙、洗脸、吹个发型
去食堂吃饭，吃了豆浆、包子和油条
去运动，和小明一起打篮球
=============================
起床、刷牙、洗脸、吹个发型
吃饭选择点外卖，点了阿强酸菜鱼和一份米饭
去运动了，和女朋友小红一起打羽毛球
晚上和女朋友去开房了

模板方法模式的优缺点

优点

• 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
• 它在父类中提取了公共的部分代码，便于代码复用。
• 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

缺点

• 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
• 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度