设计模式-模板模式详解

模板模式的定义

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式

模板模式的特点

• 意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤

• 主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

• 何时使用：有一些通用的方法。

• 如何解决：将这些通用算法抽象出来。

• 关键代码：在抽象类实现，其他步骤在子类实现。

• 应用实例： 1、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81难，这就是一个顶层的逻辑骨架。 3、spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存

• 优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

• 缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

• 使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

• 注意事项：为防止恶意操作，一般模板方法都加上 final 关键词

现实生活中的模板

勤劳的小伙伴都做过饭吧？一起炒个菜吧！

以上，炒茄子和炒藕带都可以大致分成四步，其中第一和第四步都是一样的，第二步因为炒的菜不同，第三步根据口味放的调料不同，但无论是炒啥菜都基本遵循以上四步，只是个别步骤内容不同，这样我们就可以把上面的步骤抽象成模板，如下：

模板的代码实现

上面的模板是现实世界的抽象出来的，如何在代码的世界实现呢？

一般需要一个基类及其子类进行实现，基类一般是一个抽象类，为所有子类提供算法框架；子类则根据自身需求提供具体的实现。上面的可以炒XXX的模板可以理解为抽象基类，炒茄子或炒藕带就是具体子类

代码实现如下：
抽象基类

/**
 * 抽象基类，为所有子类提供算法框架
 * （为什么是抽象类而不是接口？ 因为抽象类内允许实现一些共有或通用的方法，这些方法就
 *  无需每个子类再去实现了，如上面的”准备炒锅“和“装盘”是通用无差别的方法，可以直接在
 *  基类实现；而接口内都为抽象方法，不能实现一些通用的方法）
 */
public abstract class Cooking {
 
    /** 炒菜的步骤模板方法   final修饰说明不可被继承修改，模板方法流程是固定的 */
    public final void doCooking(){
        // 1.准备炒锅
        preparePot();
        // 2.开始炒菜
        startFry();
        // 3.放调料
        addCondiments();
        // 4.装盘
        panning();
    }
 
    /** 1.准备炒锅（该方法为通用无差别方法，直接在基类里实现，private则子类不可见） */
    private void preparePot(){
        System.out.println("准备炒锅");
    }
 
    /**
     * 2.开始炒菜
     * （该方法为个性化方法，延迟到子类里实现，定义为抽象方法
     *   因此不能用private修饰，用该为protected或default）
     */
    protected abstract void startFry();
 
    /**
     * 3.放调料
     * （该方法为个性化方法，延迟到子类里实现，定义为抽象方法
     *   因此不能用private修饰，用该为protected或default）
     */
    protected abstract void addCondiments();
 
    /** 4.装盘（该方法为通用无差别方法，直接在基类里实现，private则子类不可见） */
    private void panning(){
        System.out.println("装盘");
    }
}

炒茄子子类

public class Eggplant extends Cooking{
 
    @Override
    protected void startFry() {
        System.out.println("开始炒茄子");
    }
 
    @Override
    protected void addCondiments() {
        System.out.println("放盐");
    }
}

炒藕带子类

/**
 * 子类：炒藕带
 */
public class Lotus extends Cooking{
 
    @Override
    protected void startFry() {
        System.out.println("开始炒藕带");
    }
 
    @Override
    protected void addCondiments() {
        System.out.println("放醋");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Cooking cookEggplant = new Eggplant();
        Cooking cookLotus = new Lotus();
        cookEggplant.doCooking();
        System.out.println("-----------");
        cookLotus.doCooking();
    }
}

结果：

准备炒锅
开始炒茄子
放盐
装盘
-----------
准备炒锅
开始炒藕带
放醋
装盘

总结

1、这里延迟到子类里面实现的方法都是用protect修饰的，为什么？
一方面，这种方法只有子类才能实现，其他外部类不能实现，protect修饰可以满足要求；
另一方面，这里不用public是因为模板类里面的方法组成一个整体流程，给外面的类实现其中一个也没有意义
2、模板设计的现实需要两个要素：抽象基类和子类
抽象基类中，将部分通用无差别的逻辑以具体方法实现；另外个性化差异的部分声明成抽象方法，在其子类中延迟实现；钩子方法增加子类的灵活性；最后将所有方法汇总成一个finnal修饰的模板方法，调用该方法即可完成整个流程