瑞_23种设计模式_模板方法模式

文章目录

- 1 模板方法模式（Template Pattern） ★ 钩子函数
- - 1.1 介绍
  - 1.2 概述
  - 1.3 模板方法模式的结构
  - 1.4 模板方法模式的优缺点
  - 1.5 模板方法模式的使用场景
- 2 案例一
- - 2.1 需求
  - 2.2 代码实现
- 3 案例二
- - 3.1 需求
  - 3.2 代码实现
- 4 JDK源码解析（InputStream类）

🙊 前言：本文章为瑞_系列专栏之《23种设计模式》的模板方法模式篇。本文中的部分图和概念等资料，来源于博主学习设计模式的相关网站《菜鸟教程 | 设计模式》和《黑马程序员Java设计模式详解》，特此注明。本文中涉及到的软件设计模式的概念、背景、优点、分类、以及UML图的基本知识和设计模式的6大法则等知识，建议阅读《瑞_23种设计模式_概述》

本系列 - 设计模式 - 链接：《瑞_23种设计模式_概述》

⬇️本系列 - 创建型模式 - 链接🔗

单例模式：《瑞_23种设计模式_单例模式》
工厂模式：《瑞_23种设计模式_工厂模式》
原型模式：《瑞_23种设计模式_原型模式》
抽象工厂模式：《瑞_23种设计模式_抽象工厂模式》
建造者模式：《瑞_23种设计模式_建造者模式》

⬇️本系列 - 结构型模式 - 链接🔗

代理模式：《瑞_23种设计模式_代理模式》
适配器模式：《瑞_23种设计模式_适配器模式》
装饰者模式：《瑞_23种设计模式_装饰者模式》
桥接模式：《瑞_23种设计模式_桥接模式》
外观模式：《瑞_23种设计模式_外观模式》
组合模式：《瑞_23种设计模式_组合模式》
享元模式：《瑞_23种设计模式_享元模式》

⬇️本系列 - 行为型模式 - 链接🔗

模板方法模式：《后续更新》
策略模式：《后续更新》
命令模式：《后续更新》
职责链模式：《后续更新》
状态模式：《后续更新》
观察者模式：《后续更新》
中介者模式：《后续更新》
迭代器模式：《后续更新》
访问者模式：《后续更新》
备忘录模式：《后续更新》
解释器模式：《后续更新》

在这里插入图片描述

1 模板方法模式（Template Pattern） ★ 钩子函数

注意：为防止恶意操作，一般模板方法都加上 final 关键字。

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

瑞：行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。
瑞：行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

模板方法模式属于：类行为型模式

1.1 介绍

意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
主要解决：一些方法通用，却在每一个子类都重新写了这一方法。
何时使用：有一些通用的方法。
如何解决：将这些通用算法抽象出来。
关键代码：在抽象类实现，其他步骤在子类实现。
应用实例：
1️⃣ 在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。
2️⃣ 西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。
3️⃣ spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。
优点：
1️⃣ 封装不变部分，扩展可变部分。
2️⃣ 提取公共代码，便于维护。
3️⃣ 行为由父类控制，子类实现。
缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
使用场景：
1️⃣ 有多个子类共有的方法，且逻辑相同。
2️⃣ 重要的、复杂的方法，可以考虑作为模板方法。
注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。

1.2 概述

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

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

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

1.3 模板方法模式的结构

模板方法（Template Method）模式包含以下主要角色：
1️⃣ 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。
1️⃣➖1️⃣ 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
1️⃣➖2️⃣ 基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：
1️⃣➖2️⃣➖1️⃣ 抽象方法(Abstract Method) ：一个抽象方法由抽象类声明、由其具体子类实现。
1️⃣➖2️⃣➖2️⃣ 具体方法(Concrete Method) ：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。
1️⃣➖2️⃣➖3️⃣ 钩子方法(Hook Method) ：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
2️⃣ 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤。

一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。

1.4 模板方法模式的优缺点

优点：

提高代码复用性
将相同部分的代码放在抽象的父类中，而将不同的代码放入不同的子类中。
实现了反向控制
通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制，并符合“开闭原则”。

缺点：

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

1.5 模板方法模式的使用场景

算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
需要通过子类来决定父类算法中某个步骤是否执行，实现子类对父类的反向控制。

2 案例一

【案例】炒菜

2.1 需求

正文模版炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下：

在这里插入图片描述

2.2 代码实现

定义模板方法和基本方法（抽象类）

/**
 * 抽象类（定义模板方法和基本方法）
 *
 * @author LiaoYuXing-Ray
 **/
public abstract class AbstractClass {

    // 模板方法定义 为防止恶意操作，一般模板方法都加上 final 关键词
    public final void cookProcess() {
        pourOil();
        heatOil();
        pourVegetable();
        pourSauce();
        fry();
    }

    // 第一步：倒油是一样的，所以直接实现
    public void pourOil() {
        System.out.println("倒油");
    }

    // 第二步：热油是一样的，所以直接实现
    public void heatOil() {
        System.out.println("热油");
    }

    // 第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
    public abstract void pourVegetable();

    // 第四步：倒调味料是不一样
    public abstract void pourSauce();


    // 第五步：翻炒是一样的，所以直接实现
    public void fry(){
        System.out.println("炒啊炒啊炒到熟啊");
    }
}

炒包菜类（类）

/**
 * 炒包菜类
 *
 * @author LiaoYuXing-Ray
 **/
public class ConcreteClass_BaoCai extends AbstractClass {

    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是包菜");
    }
    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是辣椒");
    }
}

炒菜心类（类）

/**
 * 炒菜心类
 *
 * @author LiaoYuXing-Ray
 **/
public class ConcreteClass_CaiXin extends AbstractClass {

    @Override
    public void pourVegetable() {
        System.out.println("下锅的蔬菜是菜心");
    }

    @Override
    public void pourSauce() {
        System.out.println("下锅的酱料是蒜蓉");
    }
}

测试类

/**
 * 测试类
 *
 * @author LiaoYuXing-Ray
 **/
public class Client {
    public static void main(String[] args) {
        // 炒手撕包菜
        ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
        // 调用炒菜的功能
        baoCai.cookProcess();

        System.out.println("\n=== 我是一条华丽的分割线 ===\n");

        // 炒蒜蓉菜心
        ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
        // 调用炒菜的功能
        caiXin.cookProcess();
    }
}

代码运行结果如下：

	倒油
	热油
	下锅的蔬菜是包菜
	下锅的酱料是辣椒
	炒啊炒啊炒到熟啊
	
	=== 我是一条华丽的分割线 ===
	
	倒油
	热油
	下锅的蔬菜是菜心
	下锅的酱料是蒜蓉
	炒啊炒啊炒到熟啊

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

3 案例二

本案例为菜鸟教程中的案例

3.1 需求

我们将创建一个定义操作的 Game 抽象类，其中，模板方法设置为 final，这样它就不会被重写。Cricket 和 Football 是扩展了 Game 的实体类，它们重写了抽象类的方法。

TemplatePatternDemo，我们的演示类使用 Game 来演示模板模式的用法。

在这里插入图片描述

3.2 代码实现

步骤1

创建一个抽象类，它的模板方法被设置为 final。

Game.java

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();
 
   // 模板
   public final void play(){
 
      // 初始化游戏
      initialize();
 
      // 开始游戏
      startPlay();
 
      // 结束游戏
      endPlay();
   }
}

步骤2

创建扩展了上述类的实体类。

Cricket.java

public class Cricket extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}

Football.java

public class Football extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }
 
   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }
 
   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}

步骤3

使用 Game 的模板方法 play() 来演示游戏的定义方式。

TemplatePatternDemo.java

public class TemplatePatternDemo {
   public static void main(String[] args) {
 
      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();      
   }
}

步骤4

执行程序，输出结果：

	Cricket Game Initialized! Start playing.
	Cricket Game Started. Enjoy the game!
	Cricket Game Finished!
	
	Football Game Initialized! Start playing.
	Football Game Started. Enjoy the game!
	Football Game Finished!

4 JDK源码解析（InputStream类）

InputStream类就使用了模板方法模式。在InputStream类中定义了多个 read() 方法，如下：

public abstract class InputStream implements Closeable {
    // 抽象方法，要求子类必须重写
    public abstract int read() throws IOException;

    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c = read(); // 调用了无参的read方法，该方法是每次读取一个字节数据
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }
}