模板方法模式（Template Method Pattern）。

向右看齐 2024-02-17 23:39 73阅读 0赞

定义：

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

注意：为了防止恶意的操作，一般模板方法都加上final关键字，不允许被覆写。

通用代码：

抽象模板类

它的方法分为两类：

*  基本方法

基本方法也叫作基本操作，是由子类实现的方法，并且在模板方法被调用。

*  模板方法

可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调度，完成固定的逻辑。

public abstract class AbstractClass {
    
    // 基本方法
    
    protected abstract void doSomething();
    
    // 基本方法
    
    protected abstract void doAnything();
    
    // 模板方法
    
    public void templateMethod(){
    
    // 调用基本方法，完成相关的逻辑
    
    this.doAnything();
    
    this.doSomething();
    
    }
    
    }

具体模板类

public class ContreteClass1 extends AbstractClass {
    
    // 实现基本方法
    
    protected void doAnything(){
    
    // 业务逻辑处理
    
    }
    
    protected void doSomething(){
    
    // 业务逻辑处理
    
    }
    
    }

场景类

public class Client {
    
    public static void main(String[] args) {
    
    AbstractClass class1 = new ConcreteClass1();
    
    AbstrcatClass class2 = new ConcreteClass2();
    
    // 调用模板方法
    
    class1.templateMethod();
    
    class2.templateMethod();
    
    }
    
    }

注意：抽象模板中的基本方法尽量设计为protected类型，符合迪米特法则，不需要暴露或方法尽量不要设置为protected类型。实现类若非必要，尽量不要扩大父类中的访问权限。

优点：

*  封装不变部分，扩展可变部分

把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。

*  提取公共部分代码，便于维护
 *  行为由父类控制，子类实现

基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

缺点：

按照我们的设计习惯，抽象类负责声明最抽象，最一般的事物属性和方法，实现类完成具体的事物属性和方法。但是模板方法模式却颠倒了，抽象类定义了部分抽象方法， 由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度，而且也会让新手产生不适感。

使用场景：

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

案例代码：

抽象悍马模型

public abstract class HummerModel {
    
    // 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正是要能够发动起来，那这个实现要在实现类里了
    
    public abstract void start();
    
    // 能发动，还要能停下来，那才是真本事
    
    public abstract void stop();
    
    // 喇叭会出声音，是滴滴叫，还是哔哔叫
    
    public abstract void alarm();
    
    // 引擎会轰隆隆地响，不响那是假的
    
    public abstract void engineBoom();
    
    // 那模型应该会跑吧，别管是人推，还是电力驱动的，总之要会跑
    
    public void run() {
    
    //先发动车
    
    this.start();
    
    // 引擎开始轰鸣
    
    this.engineBoom();
    
    // 然后就开始跑了，跑得过程中遇到一条狗挡道，就按喇叭
    
    this.alarm();
    
    // 到达目的地就停车
    
    this.stop();
    
    }
    
    }

H1型号悍马模型（H2型悍马模型代码与其一致，省略）

public class HummerHiModel extends HummerModel {
    
    // H1型号的悍马车鸣笛
    
    public void alarm() {
    
    System.out.println("悍马H1鸣笛...");
    
    }
    
    // 引擎轰鸣声
    
    public void engineBoom() {
    
    System.out.println("悍马H1引擎声音是这样的...");
    
    }
    
    // 汽车发动
    
    public void start() {
    
    System.out.println("悍马H1发动...");
    
    }
    
    // 停车
    
    public void stop() {
    
    System.out.println("悍马H1停车...");
    
    }
    
    }

注意：在软件开发过程中，如果相同的一段代码复制过两次，就需要对设计产生怀疑，架构师要明确地说明为什么相同的逻辑要出现两次或更多次。

场景类

public class Client {
    
    public static void main(String[] args) {
    
    // XX公司要H1型号的悍马
    
    HummerModel h1 = new HummerH1Model();
    
    // H1模型演示
    
    h1.run();
    
    }
    
    }

模板方式的扩展：

环境模拟：

H1型号的悍马喇叭想让它响就响，H2型号的喇叭不要有声音。

扩展后的抽象模板类

public abstract class HummerModel {
    
    // 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正是要能够发动起来，那这个实现要在实现类里了
    
    public abstract void start();
    
    // 能发动，还要能停下来，那才是真本事
    
    public abstract void stop();
    
    // 喇叭会出声音，是滴滴叫，还是哔哔叫
    
    public abstract void alarm();
    
    // 引擎会轰隆隆地响，不响那是假的
    
    public abstract void engineBoom();
    
    // 那模型应该会跑吧，别管是人推，还是电力驱动的，总之要会跑
    
    public void run() {
    
    //先发动车
    
    this.start();
    
    // 引擎开始轰鸣
    
    this.engineBoom();
    
    // 然后就开始跑了，跑得过程中遇到一条狗挡道，就按喇叭
    
    if(this.isAlarm()) {
    
    this.alarm();
    
    }
    
    // 到达目的地就停车
    
    this.stop();
    
    }
    
    // 钩子方法，默认喇叭是会想的
    
    protected boolean isAlarm() {
    
    return true;
    
    }
    
    }

isAlarm()是一个实现方法。其作用是模板方法根据其返回值决定是否要响喇叭，子类可以覆写该方法值。

扩展后的H1悍马

public class HummerHiModel extends HummerModel {
    
    private boolean alarmFlag = true; // 要响喇叭
    
    // H1型号的悍马车鸣笛
    
    public void alarm() {
    
    System.out.println("悍马H1鸣笛...");
    
    }
    
    // 引擎轰鸣声
    
    public void engineBoom() {
    
    System.out.println("悍马H1引擎声音是这样的...");
    
    }
    
    // 汽车发动
    
    public void start() {
    
    System.out.println("悍马H1发动...");
    
    }
    
    // 停车
    
    public void stop() {
    
    System.out.println("悍马H1停车...");
    
    }
    
    protected boolean isAlarm() {
    
    reuturn this.alarmFlag;
    
    }
    
    // 要不要响喇叭，是由客户来决定的
    
    public void setAlarm(boolean isAlarm) {
    
    this.alarmFlag = isAlarm;
    
    }
    
    }

扩展后的H2悍马

public class Hummer2HiModel extends HummerModel {
    
    private boolean alarmFlag = true; // 要响喇叭
    
    // H1型号的悍马车鸣笛
    
    public void alarm() {
    
    System.out.println("悍马H1鸣笛...");
    
    }
    
    // 引擎轰鸣声
    
    public void engineBoom() {
    
    System.out.println("悍马H1引擎声音是这样的...");
    
    }
    
    // 汽车发动
    
    public void start() {
    
    System.out.println("悍马H1发动...");
    
    }
    
    // 停车
    
    public void stop() {
    
    System.out.println("悍马H1停车...");
    
    }
    
    // 默认没有喇叭的
    
    protected boolean isAlarm() {
    
    reuturn false;
    
    }
    
    }

在我们的抽象类中isAlarm的返回值就是影响了模板方法的执行结果，该方法就叫做钩子方法（Hook Method）。

模板方法模式就是在模板方法中按照一定的规则和顺序调用基本方法，具体到前面那个例子，就是run()方法按照规定的顺序调用本类的其他方法，并且由isAlarm()方法的返回值确定run()中的执行顺序变更。

最佳实践：

父类是否可以调用子类的方法呢？回答是能，但强烈的、极度的不建议这么做，那该怎么做呢？

*  把子类传递到父类的有参构造中，然后调用。
 *  使用反射的方式调用，你使用了反射还有谁不能调用的？
 *  父类调用子类的静态方法。

父类建立框架，子类在重写了父类部分的方法后，再调用从父类继承的方法，产生不同的结果（而这正是模板方法模式）。这是不是也可以理解为父类调用了子类的方法呢？你修改了子类，影响了父类行为的结果，曲线救国的方式实现了父类依赖子类的场景，模板方法模式就是这种效果。

在《xxx In Action》中就说明了，如果你需要扩展功能，可以继承这个抽象类，然后覆写protected方法，再然后就是调用一个类似execute方法，就完成你的扩展开发，非常容易扩展的一种模式。