设计模式(十)：模板方法模式

目录

1、整体框架

2、介绍

2.1、定义

2.2、作用

2.3、解决的问题

3、认识模版方法模式

3.1、变与不变

3.2、好莱坞法则

3.3、对设计原则的体现

4、模式原理

4.1、UML类图 & 组成

4.2、实例讲解

5. 优缺点

5.1 优点

5.2 缺点

6. 应用场景

1、整体框架

2、介绍

2.1、定义

模版方法模式：定义一个模版结构即抽象，将具体内容延迟到子类去实现

2.2、作用

模版方法模式是基于继承的。在不改变模版结构的前提下，在子类中重新定义模版中的内容。

2.3、解决的问题

• 提高代码的复用性：将相同部分的代码放在抽象类的父类中，而将不同的代码放到不同的子类中。
• 实现反向控制：通过父类调用子类的操作，并通过子类的具体实现扩展不同的行为，实现反向控制。

3、认识模版方法模式

3.1、变与不变

程序设计的一个很重要的思考点就是“变与不变”，也就是分析程序中哪些功能是可变的，哪些功能是不变的，然后把不变的部分抽象出来，进行公共的实现，把变化的部分分离出去，用接口来封装隔离，或者是用抽象类来约束子类行为。

接口和抽象类的选择：推荐面向接口编程，因为抽象类中可以有非抽象方法可以有实现，故当有共同的实现时可以使用抽象类。而接口在java8也添加了默认实现default。

模板方法模式很好的体现了这一点。模板类实现的就是不变的方法和算法的骨架，而需要变化的地方，都通过抽象方法，把具体实现延迟到子类去了，而且还通过父类的定义来约束了子类的行为，从而使系统能有更好的复用性和扩展性。

3.2、好莱坞法则

什么是好莱坞法则呢？简单点说，就是“不要找我们，我们会联系你”。

模版方法模式很好体现了这点，作为父类的模板会在需要的时候，调用子类相应的方法，也就是由父类找子类，而不是子类找父类。

这其实也是一种反向的控制结构，按照通常的思路，是子类找父类才对，也就是应该是子类来调用父类的方法，因为父类根本就不知道子类，而子类是知道父类的，但是在模板方法模式里面，是父类来找子类，所以是一种反向的控制结构。

3.3、对设计原则的体现

模板方法很好的体现了开闭原则和里氏替换原则。

开闭原则：对修改关闭，对扩展开放。首先从设计上，先分离变与不变，然后把不变的部分抽取出来，定义到父类里面，比如算法骨架，比如一些公共的、固定的实现等等。这些不变的部分被封闭起来，尽量不去修改它了，要扩展新的功能，那就使用子类来扩展，通过子类来实现可变化的步骤，对于这种新增功能的做法是开放的。

李氏替换原则：派生类型（子类）必须能够替换掉它们的基类型（父类），运行时子类对象覆盖父类对象。能够实现统一的算法骨架，通过切换不同的具体实现来切换不同的功能，一个根本原因就是里氏替换原则，遵循这个原则，保证所有的子类实现的是同一个算法模板(为了防止子类改变模板方法中的算法，可以将模板方法声明为final)，并能在使用模板的地方，根据需要，切换不同的具体实现。

4、模式原理

4.1、UML类图 & 组成

4.2、实例讲解

a. 实例概况

• 背景：小成希望学炒菜：手撕包菜 & 蒜蓉炒菜心
• 冲突：两道菜的炒菜步骤有的重复有的却差异很大，记不住
• 解决方案：利用代码记录下来

b. 使用步骤
步骤1： 创建抽象模板结构（Abstract Class）：炒菜的步骤

public  abstract class Cookie{  
//模板方法，用来控制炒菜的流程 （炒菜的流程是一样的-复用）
//声明为final，不希望子类覆盖这个方法，防止更改流程的执行顺序 
        final void cookProcess(){  
        //第一步：倒油
        this.pourOil()；
        //第二步：热油
         this.HeatOil();
        //第三步：倒蔬菜
         this.pourVegetable();
        //第四步：倒调味料
         this.pourSauce（）；
        //第五步：翻炒
         this.fry();
    }  
//定义结构里哪些方法是所有过程都是一样的可复用的，哪些是需要子类进行实现的

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

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

//第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
//所以声明为抽象方法，具体由子类实现 
    abstract void  pourVegetable()；

//第四步：倒调味料是不一样的（一个下辣椒，一个是下蒜蓉）
//所以声明为抽象方法，具体由子类实现 
    abstract void  pourSauce（）；


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

步骤2： 创建具体模板（Concrete Class）,即”手撕包菜“和”蒜蓉炒菜心“的具体步骤

//炒手撕包菜的类
  public class ConcreteClass_BaoCai extend  Abstract Class{
    @Override
    public void  pourVegetable(){  
        System.out.println(”下锅的蔬菜是包菜“);  
    }  
    @Override
    public void  pourSauce（）{  
        System.out.println(”下锅的酱料是辣椒“);  
    }  
}
//炒蒜蓉菜心的类
  public class ConcreteClass_CaiXin extend  Abstract Class{
    @Override
    public void  pourVegetable(){  
        System.out.println(”下锅的蔬菜是菜心“);  
    }  
    @Override
    public void  pourSauce（）{  
        System.out.println(”下锅的酱料是蒜蓉“);  
    }  
}

步骤3：客户端调用-炒菜了

public class Template Method{
  public static void main(String[] args){

//炒 - 手撕包菜
    ConcreteClass_BaoCai BaoCai = new ConcreteClass_BaoCai（）；
    BaoCai.cookProcess()；

//炒 - 蒜蓉菜心
  ConcreteClass_ CaiXin = new ConcreteClass_CaiXin（）；
    CaiXin.cookProcess()；
    }
        
}
   

结果输出

倒油
热油
下锅的蔬菜是包菜
下锅的酱料是辣椒
炒啊炒啊炒到熟

倒油
热油
下锅的蔬菜是菜心
下锅的酱料是蒜蓉
炒啊炒啊炒到熟

5. 优缺点

5.1 优点

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

5.2 缺点

引入了抽象类，每一个不同的实现都需要一个子类来实现，导致类的个数增加，从而增加了系统实现的复杂度。

6. 应用场景

• 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现；
• 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复；
• 控制子类的扩展。

参考：Carson带你学设计模式：模板方法模式（Template Method）_Carson带你学Android-CSDN博客

李氏替换原则：面向对象设计原则之3-里氏替换原则_比特飞-CSDN博客