设计模式 - 行为型模式考点篇：模板方法模式（概念 | 案例实现 | 优缺点 | 使用场景）

朴灿烈づ我的快乐病毒、 2024-02-23 04:12 68阅读 0赞

**目录**

一、行为型模式

1.1、模板方法模式

1.1.1、概念

1.1.2、案例实现

1.1.3、优缺点

1.1.4、使用场景

--------------------

## 一、行为型模式 ##

--------------------

### 一句话概括行为型模式 ###

行为型模式：类或对象间如何交互、如何划分职责，从而更好的完成任务.

### 1.1、模板方法模式 ###

#### 1.1.1、概念 ####

在一个算法骨架中，将某些算法的步骤延迟倒子类中，使得这些算法的可以根据具体的环境实现.

这就像是，我们在设计一个程序的时候经常可能会遇到这种情况：“设计了一个算法步骤，确定了这些步骤的执行顺序，但其中某些步骤还是未知，需要根据具体的业务情况而定”，此时就可以使用模板方法模式，使其放到子类实现.

*例如，炒菜的步骤时固定的，分为倒油、热油、倒入要炒食物、倒调料、翻炒这几个步骤，其中 倒油、热油、翻炒这几个步骤是固定的，而炒什么食物 和 倒调料 都是要根据情况而定的.*

模板方法模式包含角色：

*  抽象类：给出一套算法的具体实现和执行顺序，其中包含一些在子类中实现的抽象方法.
 *  具体子类：实现抽象类中定义的抽象方法，他们也是算法执行逻辑的组成步骤.

#### 1.1.2、案例实现 ####

例如上述炒菜案例.

/**
     * 抽象类: 做菜类
     */
    public abstract class DoCooking {
    
        public void doCooking() {
            //1.倒油
            pourOil();
            //2.热油
            hotOil();
            //3.倒食物
            pourFood();
            //4.添加调料
            addSeasoning();
            //5.翻炒
            fry();
        }
    
        private void pourOil() {
            System.out.println("倒油");
        }
    
        private void hotOil() {
            System.out.println("热油");
        }
    
        /**
         * 添加食物
         */
        protected abstract void pourFood();
    
        /**
         * 添加调料
         */
        protected abstract void addSeasoning();
    
        private void fry() {
            System.out.println("翻炒");
        }
    
    
    
    }

/**
     * 具体子类: 处理鸡蛋
     */
    public class HandlerEgg extends DoCooking {
    
        @Override
        protected void pourFood() {
            System.out.println("将鸡蛋下锅");
        }
    
        @Override
        protected void addSeasoning() {
            System.out.println("添加酱油");
        }
    
    }

/**
     * 具体子类: 处理米饭
     */
    public class HandlerRice extends DoCooking {
    
        @Override
        protected void pourFood() {
            System.out.println("将米饭下锅");
        }
    
        @Override
        protected void addSeasoning() {
            System.out.println("添加葱花");
        }
    
    }

public class Client {
    
        public static void main(String[] args) {
            //1.炒鸡蛋
            HandlerEgg egg = new HandlerEgg();
            egg.doCooking();
            System.out.println("===================");
            //2.炒米饭
            HandlerRice rice = new HandlerRice();
            rice.doCooking();
        }
    
    }

执行结果如下：

![58fd25ed836342959d4db7d9e0e134fd.png][]

#### 1.1.3、优缺点 ####

> 优点：

提高代码复用性：将相同代码放到抽象的父类中，不同实现放到不同子类中.

符合开闭原则：将来如果增加一个相关业务吗，只需要扩展实现一个子类，无需修改原有代码.

> 缺点：

增加系统复杂度：每一个不同实现都需要定义一个子类，会导致类的数量增加，系统更加庞大.

#### 1.1.4、使用场景 ####

1.  算法的整体步骤固定，只有个别容易改变.
2.  需要通过子类来决定父类算法中的某步骤的具体实现.

![d5b14d719dc947889be7390fc76b96aa.gif][]

[58fd25ed836342959d4db7d9e0e134fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/23/ad6e22925df64c2a8ce94f25b9ca3b38.png
[d5b14d719dc947889be7390fc76b96aa.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/23/e073e517c76549b1adc1da17ee7c0b82.png