【Java设计模式】十三、模板方法模式

蔚落 2024-04-23 15:54 7阅读 0赞

#### 文章目录 ####

*  1、模板方法模式
 *  2、案例：炒菜
 *  3、总结
 *  4、源码中的实际应用

结构型大类的设计模式完结，接下来是行为型大类的设计模式，行为型的11种设计模式描述的是多个类和对象之间互相协作，共同完成单个对象无法完成的任务。

## 1、模板方法模式 ##

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

> 定义好一套抽象的实现步骤，将一些看情况而定的步骤延迟到子类中去实现，使得子类可以在不改变原算法步骤的情况下，重新定义某些特定步骤。

模板方法模式的角色：

**1）抽象类**：一套实现骨架，包括模板方法 + 基本方法

其中：

*  模板方法：定义了按某种顺序调用基本方法，如先取号、排队，再办业务
 *  基本方法：实现每一步的方法，分为：  
      
    。抽象方法：看情况而定的那部分逻辑，由子类去实现，如办理业务，有人存款，有人取款  
      
    。具体方法：共同逻辑对应的方法，如取号、排队，可在抽象类中实现（提高一点复用性），也可在子类中覆盖  
      
    。钩子方法：用于判断的逻辑方法，`Boolean isXxx()`

**2）具体子类**：按具体需求实现抽象类的抽象方法和钩子方法

## 2、案例：炒菜 ##

炒菜，步骤为：倒油、热油、倒蔬菜、倒调料、翻炒，这是算法骨架（模板方法）。倒油、热油、翻炒是固定的（具体方法），倒蔬菜和倒调料是因菜而异的（抽象方法）。以炒包菜和炒菜心两个菜为例，类图：

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

先定义抽象类，注意模板方法加final关键字，不让子类重写，因为这个调用是固定的

public abstract class AbstractClass {
        
        
        //模板方法，这里规定了基本方法的调用步骤
        public final void cookProcess() {
        
            //第一步：倒油
            this.pourOil();
            //第二步：热油
            this.heatOil();
            //第三步：倒蔬菜
            this.pourVegetable();
            //第四步：倒调味料
            this.pourSauce();
            //第五步：翻炒
            this.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("炒啊炒啊炒到熟啊");
        }
    }

定义炒包菜的子类，继承抽象类：

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

同理，定义炒另一个菜的子类：

public class ConcreteClass_CaiXin extends AbstractClass {
        
        @Override
        public void pourVegetable() {
        
            System.out.println("下锅的蔬菜是菜心");
        }
    
        @Override
        public void pourSauce() {
        
            System.out.println("下锅的酱料是蒜蓉");
        }
    }

测试下效果：

public class Client {
        
        public static void main(String[] args) {
        
            //炒手撕包菜
            ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
            //调用父类的炒菜的方法
            baoCai.cookProcess();
    
            //炒蒜蓉菜心
            ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
            caiXin.cookProcess();
        }
    }

运行：

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

后续炒其他菜，定义新的子类即可，且只需重写倒蔬菜和倒调料这两个方法。

## 3、总结 ##

优点：

*  代码复用性：复用抽象类的通用逻辑方法
 *  反向控制

适用场景：

*  整体实现步骤固定，个别步骤易变，将易变的部分抽象出来
 *  通过子类来决定父类算法中的某个步骤是否执行，实现子类对父类的反向控制（钩子函数）

## 4、源码中的实际应用 ##

InputStream类的read方法，无参的为抽象方法，给子类去实现，底下的read方法为模板方法，调用了这个抽象的read方法

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

[f46bc2d7760c43e7931d127af5fc59d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5ec779f18ef44af0bb7a2fc6c97d58d9.png
[ad969e1007ee43259b396575ad0e88fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/ce532ee564ba490f9becdfcf678e5e4d.png
[cf7554579372412d9ee161a782dfa7a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f96eef40c64248ecb614df65ebe303dd.png