模板方法模式，来看这里的最香！

介绍

在面向对象开发过程中，通常会遇到这样的一个问题，我们知道一个算法所需的关键步骤，并确定了这些步骤的执行顺序，但是，某些步骤的具体实现是未知的，或者说某些步骤的实现是会随着环境的变化而改变的，例如，执行程序的流程大致如下:

1. 检查代码的正确性；
2. 链接相关的类库；
3. 编译相关代码；
4. 执行程序；

对于不同的程序设计语言，上述 4 个步骤都是不一样的，但是，它们的执行流程是固定的，这类问题的解决方案就是这们这篇的主要内容 - 模板方法模式。

定义

定义一个操作中算法的框架，将一些步骤交于子类具体实现，使得子类可以改变一个算法的结构即可重定义该算法的某些特定步骤。

使用场景

1. 多个子类有公有的方法，并且逻辑基本相同时。
2. 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
3. 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。

UML 类图

• AbsTemplate: 抽象类，定义了一套算法框架。
• ConcreteImplA: 具体实现类 A。
• ConcreteImpleB: 具体实现类 B。

代码示例

模板方法模式实际上是封装一个固定流程，就像是一套执行模板一样，第一步该做什么，第二步该做什么都已经在抽象类中定义好。而子类可以有不同的算法实现，在框架不被修改的情况下实现某些步骤的算法替换，下面就就以简单示例来说明一下。

简单示例

需求： 用代码简要描述开机过程

定义抽象的模板

  public abstract class AbstractComputer {

      /**
       * 开启电源
       */
      protected void powerOn(){
          System.out.println("开启电源");
      }

      /**
       * 硬件检查
       */
      protected void checkHardware(){
          System.out.println("硬件检查");
      }

      /**
       * 加载系统
       */
      protected void loadSystem(){
          System.out.println("加载系统");
      }

      /**
       * 屏幕显示
       */
      protected void showScreen(){
          System.out.println("屏幕显示");
      }

      /**
       * 输入用户信息
       */
      protected void login(){
          System.out.println("密码验证成功，进入主页面。");
      }

      /**
       * 启动计算机方法，步骤固定为开启电源、硬件检查、加载系统、屏幕显 
 示、登录。设计为 final 防止被重写
       */
      public final void startUp(){
          System.out.println("------>>>>>>>   startup  ");
          powerOn();
          checkHardware();
          loadSystem();
          showScreen();
          login();
          System.out.println("------>>>>>>>   Successful");
      }
  }

抽象模板实现 A

  public class CoderComputer extends AbstractComputer {

      @Override
      protected void login() {
          System.out.println("密码输入完成，交于系统检查。");
          super.login();
      }
  }

抽象模板实现 B

  public class MilitaryComputer extends AbstractComputer {

      @Override
      protected void checkHardware() {
          super.checkHardware();
          System.out.println("检查防火墙");
      }

      @Override
      protected void login() {
          System.out.println("视网膜扫描 \n 视网膜验证成功");
          super.login();
      }
  }

test

    @Test
    public void testTemplate(){

        AbstractComputer abstractComputerA = new CoderComputer();
        abstractComputerA.startUp();

        AbstractComputer abstractComputerB = new MilitaryComputer();
        abstractComputerB.startUp();
    }

output

   程序员电脑启动流程
  ------>>>>>>>   startup  
  开启电源
  硬件检查
  加载系统
  屏幕显示
  密码输入完成，交于系统检查。
  密码验证成功，进入主页面。
  ------>>>>>>>   Successful

  军用电脑启动流程
  ------>>>>>>>   startup  
  开启电源
  硬件检查
  检查防火墙
  加载系统
  屏幕显示
  视网膜扫描 
  视网膜验证成功
  密码验证成功，进入主页面。
  ------>>>>>>>   Successful

通过上面的模板例子可以看到 ，在 startUp 方法中有一些固定的执行顺序，但是，不同的场景执行实现的步骤各不相同，因此子类需要复写相应的方法来进行自定义处理，这里需要注意的是 startUp 为 final 方法，这样就可以保证模板的执行顺序不被外部更改，子类更改某一时刻执行的具体实现，这样就保证了整个逻辑流程的稳定性。

总结

模板方法模式用 4 个字概括就是：流程封装。也就是把某个固定的流程封装到一个 final 函数中，并让子类能够定制这个流程中的某些或者所有步骤，这就要求父类提取共用的代码，提升代码复用率，同时也带来了更好的可扩展性。

优点:

1. 封装不变部分，扩展可变部分。
2. 提取公共部分代码，便于维护。

缺点:

1. 模板方法会带来代码阅读的难度，会让用户觉得难以理解。