Java 23种设计模式（13.行为型模式-模板方法模式）

蔚落 2023-09-23 23:02 28阅读 0赞

> # 行为型模式-`模板方法模式` #

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

行为型模式分为：

1.  模板方法模式
2.  策略模式
3.  命令模式
4.  职责链模式
5.  状态模式
6.  观察者模式
7.  中介者模式
8.  迭代器模式
9.  访问者模式
10. 备忘录模式
11. 解释器模式  
    以上 11 种行为型模式，除了`模板方法模式`和`解释器模式`是**类行为型模式**，其他的全部属于**对象行为型模式**。

# 代码解析 #

## 类图 ##

![在这里插入图片描述][78f68ec92fbd47bebd458fd77af12d02.png]

## 代码 ##

abstract  class AbstractClass {
        
        public final void template(){
        
            this.operation1();
            this.operation2();
    
    
        }
        abstract void operation1();
        abstract void operation2();
    }

public class ConcreteClassA extends AbstractClass{
        
        @Override
        void operation1() {
        
            System.out.println("ClassA: concrete operation1");
        }
    
        @Override
        void operation2() {
        
            System.out.println("ClassA: concrete operation2");
        }
    }

public class ConcreteClassB extends AbstractClass{
        
        @Override
        void operation1() {
        
            System.out.println("ClassB: concrete operation1");
        }
    
        @Override
        void operation2() {
        
            System.out.println("ClassB: concrete operation2");
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            AbstractClass a;
            a = new ConcreteClassA();
            a.template();
            System.out.println("--------------");
            a = new ConcreteClassB();
            a.template();
        }
    }

ClassA: concrete operation1
    ClassA: concrete operation2
    --------------
    ClassB: concrete operation1
    ClassB: concrete operation2

## 运行结果 ##

# 1.概述 #

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

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

**定义：**

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

# 2.结构 #

`模板方法（Template Method）`模式包含以下主要角色：

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

# 3. 类图 #

【例】炒菜

炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。  
![在这里插入图片描述][31062d521d744e1c8b9b0f7c1146c7ad.png]

# 4. 代码 #

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

abstract class AbstractClass {
        
        //模板方法定义
        public final void cookprocess(){
        
            this.pourOil();
            this.heatOil();
            this.pourVegetable();
            this.pourSauce();
            this.fry();
        }
        //第一步：倒油是一样的，所以直接实现
        public void pourOil(){
        
            System.out.println("need oil");
        }
        //第二步：热油是一样的，所以直接实现
        public void heatOil(){
        
            System.out.println("heat oil");
        }
    
        //第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
        abstract void pourVegetable() ;
        //第四步：倒调味料是不一样
        abstract void pourSauce();
        //第五步：翻炒是一样的，所以直接实现
        public void fry(){
        
            System.out.println("need to fry");
        }
    
    }

public class ConcreteClass_BaoCai extends AbstractClass{
        
        @Override
        void pourVegetable() {
        
            System.out.println("put vegetable");
        }
    
        @Override
        void pourSauce() {
        
            System.out.println("put chili");
        }
    }

public class ConcreteClass_Caixin extends AbstractClass{
        
        @Override
        void pourVegetable() {
        
            System.out.println("put caxin");
        }
    
        @Override
        void pourSauce() {
        
            System.out.println("add minced garlic");
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            ConcreteClass_BaoCai a = new ConcreteClass_BaoCai();//或者使用 AbstractClass a = new ConcreteClass_BaoCai();
            a.cookprocess();//如果不在抽象类加入模板方法cookprocess(),新建后的对象需要调所有的方法，这很不方便
            System.out.println("-----------");
            ConcreteClass_Caixin b = new ConcreteClass_Caixin();
            b.cookprocess();
        }
    }

need oil
    heat oil
    put vegetable
    put chili
    need to fry
    -----------
    need oil
    heat oil
    put caxin
    add minced garlic
    need to fry

# 5.优缺点 #

**优点：**

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

**缺点：**

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

# 6. 使用场景 #

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

# 7.源码解析 #

`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;
        }
    }

从上面代码可以看到，无参的 `read()` 方法是抽象方法，要求子类必须实现。而 `read(byte b[])` 方法调用了 `read(byte b[], int off, int len)` 方法，所以在此处重点看的方法是带三个参数的方法。

在该方法中第18行、27行，可以看到调用了无参的抽象的 `read()` 方法。

**总结如下：** 在InputStream父类中已经定义好了读取一个字节数组数据的方法是每次读取一个字节，并将其存储到数组的第一个索引位置，读取len个字节数据。具体如何读取一个字节数据呢？由子类实现。

[78f68ec92fbd47bebd458fd77af12d02.png]: https://img-blog.csdnimg.cn/78f68ec92fbd47bebd458fd77af12d02.png
[31062d521d744e1c8b9b0f7c1146c7ad.png]: https://img-blog.csdnimg.cn/31062d521d744e1c8b9b0f7c1146c7ad.png