设计模式之禅【模板方法模式】

痛定思痛。 2022-06-02 09:40 155阅读 0赞

# 真刀实枪之模板方法模式 #

*  辉煌工程
    
     *  做个悍马车模，不是香车美女的那个车模哦！
     *  要做分析，做模板，做测试，还要考虑扩展性、稳定性、健壮性等。
     *  那先简单做个类图吧
     *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70][]
     *  代码
        
         *  HummerModel抽象类
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public abstract class HummerModel {
                    // 发动车
                    public abstract void start();
                
                    // 停车
                    public abstract void stop();
                
                    // 响喇叭
                    public abstract void alarm();
                
                    // 引擎
                    public abstract void engineBoom();
                
                    // 运行
                    public abstract void run();
                }
         *  H1型号的悍马车
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public class HummerH1Model extends HummerModel {
                    @Override
                    public void start() {
                        System.out.println("H1悍马发动！");
                    }
                
                    @Override
                    public void stop() {
                        System.out.println("H1悍马停止！");
                    }
                
                    @Override
                    public void alarm() {
                        System.out.println("H1悍马鸣笛！");
                    }
                
                    @Override
                    public void engineBoom() {
                        System.out.println("H1悍马引擎声音。。。");
                    }
                
                    @Override
                    public void run() {
                        this.start();// 发动汽车
                        this.engineBoom();// 引擎启动
                        this.alarm();// 按喇叭
                        this.stop();// 到达目的地停车
                    }
                
                }
         *  H2型号的悍马车
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public class HummerH1Model extends HummerModel {
                    @Override
                    public void start() {
                        System.out.println("H2悍马发动！");
                    }
                
                    @Override
                    public void stop() {
                        System.out.println("H2悍马停止！");
                    }
                
                    @Override
                    public void alarm() {
                        System.out.println("H2悍马鸣笛！");
                    }
                
                    @Override
                    public void engineBoom() {
                        System.out.println("H2悍马引擎声音。。。");
                    }
                
                    @Override
                    public void run() {
                        this.start();// 发动汽车
                        this.engineBoom();// 引擎启动
                        this.alarm();// 按喇叭
                        this.stop();// 到达目的地停车
                    }
                
                }
     *  上述代码出现的问题：run方法一模一样，那这个run方法应该出现在抽象类，不应该出现在实现类，抽象是所有子类的共性封装。好了，修改类图吧：
     *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1][]
     *  代码相应修改为：
        
         *  HummerModel抽象类
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public abstract class HummerModel {
                    // 发动车
                    public abstract void start();
                
                    // 停车
                    public abstract void stop();
                
                    // 响喇叭
                    public abstract void alarm();
                
                    // 引擎
                    public abstract void engineBoom();
                
                    // 运行
                    public abstract void run(){
                        this.start();// 发动汽车
                        this.engineBoom();// 引擎启动
                        this.alarm();// 按喇叭
                        this.stop();// 到达目的地停车
                    }
                }
         *  H1型号的悍马车
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public class HummerH1Model extends HummerModel {
                    @Override
                    public void start() {
                        System.out.println("H1悍马发动！");
                    }
                
                    @Override
                    public void stop() {
                        System.out.println("H1悍马停止！");
                    }
                
                    @Override
                    public void alarm() {
                        System.out.println("H1悍马鸣笛！");
                    }
                
                    @Override
                    public void engineBoom() {
                        System.out.println("H1悍马引擎声音。。。");
                    }
                
                }
         *  H2型号的悍马车
            
                package com.peng.car;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月16日
                 * @description
                 */
                public class HummerH1Model extends HummerModel {
                    @Override
                    public void start() {
                        System.out.println("H2悍马发动！");
                    }
                
                    @Override
                    public void stop() {
                        System.out.println("H2悍马停止！");
                    }
                
                    @Override
                    public void alarm() {
                        System.out.println("H2悍马鸣笛！");
                    }
                
                    @Override
                    public void engineBoom() {
                        System.out.println("H2悍马引擎声音。。。");
                    }
                
                }

### 模板方法的定义 ###

*  Themplate Method Pattern
 *  Define the skeleton of an algorithm in an operation,deferring some steps to subclasses.Template Method lets of an algorithm without changing certain steps of an algorithm without changing the algorithm's structure.(定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤)
 *  通用类图
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2][]
    
     *  类图解释
        
        1.  基本方法--也叫基本操作，是由子类实现的方法，并且在模板方法中被调用。
        2.  模板方法--可以有几个或一个，一般是一个具体的方法，也就是一个框架，实现对基本方法的调用，完成固定的逻辑。
 *  通用代码
    
     *  抽象模板类
        
            package com.peng.car;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月16日
             * @description
             */
            public abstract class AbstractClass {
                // 基本方法
                protected abstract void doSomething();
            
                // 基本方法
                protected abstract void doAnything();
            
                // 模板方法
                public void templateMethod() {
                    // 调用基本方法
                    this.doAnything();
                    this.doSomething();
                }
            }
     *  具体模板类1
        
            package com.peng.car;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月16日
             * @description
             */
            public class ConcreteClass1 extends AbstractClass {
            
                @Override
                protected void doSomething() {
                    //具体模板1的业务逻辑
                }
            
                @Override
                protected void doAnything() {
                    // 具体模板1的业务逻辑
            
                }
            
            }
     *  具体模板类2
        
            package com.peng.car;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月16日
             * @description
             */
            public class ConcreteClass2 extends AbstractClass {
            
                @Override
                protected void doSomething() {
                    // 具体模板2的业务逻辑
                }
            
                @Override
                protected void doAnything() {
                    // 具体模板2的业务逻辑
            
                }
            
            }

### 注意 ###

*  抽象模板中的基本方法尽量设计为protected类型，符合迪米特法则不需要暴露的属性或方法尽量不要设置为protected类型，实现类若非必要，尽量不要扩大父类中的访问权限。

### 模板方法模式的应用 ###

*  优点
    
        1. 封装不变的部分，扩展可变的部分
        2. 提取公共的部分，便于维护
        3. 行为由父类控制，子类实现具体的细节
 *  缺点
    
    1.  按照实际习惯，抽象类负责声明抽象、最一般的事物属性和方法。但是模板方法却颠倒了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响
    2.  这在复杂的项目中，带来阅读的难度，而且也会让新手产生不适感。

### 模板方法的使用场景 ###

*  多个子类有公有的方法，并且逻辑基本相同时
 *  重要、复杂的算法，可以把核心算法设计为模板方法，周边的细节功能则由各个子类实现
 *  重构时，模板方法模式是一个经常使用的模式，把相同的代码放到父类中，然后通过钩子函数约束其行为。

### 模板方法的扩展--钩子方法的引入 ###

*  Hook Method
 *  类图
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3][]
 *  代码
    
     *  抽象类
        
            package com.peng.car;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月16日
             * @description
             */
            public abstract class HummerModel {
                // 发动车
                public abstract void start();
            
                // 停车
                public abstract void stop();
            
                // 响喇叭
                public abstract void alarm();
            
                // 引擎
                public abstract void engineBoom();
            
                // 钩子方法
                protected boolean isAlarm() {
                    return true;// 默认喇叭会响
                }
            
                // 运行
                public void run() {
                    this.start();// 发动汽车
                    this.engineBoom();// 引擎启动
                    if (this.isAlarm()) {
                        this.alarm();// 按喇叭
                    }
                    this.stop();// 到达目的地停车
                }
            }
     *  客户类
        
            package com.peng.car;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月16日
             * @description
             */
            public class HummerH1Model extends HummerModel {
                private boolean alarmFlag = true;// 默认车的喇叭响
            
                @Override
                public void start() {
                    System.out.println("H1悍马发动！");
                }
            
                @Override
                public void stop() {
                    System.out.println("H1悍马停止！");
                }
            
                @Override
                public void alarm() {
                    System.out.println("H1悍马鸣笛！");
                }
            
                @Override
                public void engineBoom() {
                    System.out.println("H1悍马引擎声音。。。");
                }
            
                // 配合钩子方法
                protected boolean isAlarm() {
                    return this.alarmFlag;
                }
            
                // 喇叭响不响，有客户来决定
                public void setAlarm(boolean isAlarm) {
                    this.alarmFlag = isAlarm;
                }
            }

### 最佳实践 ###

*  父类怎么调用子类的方法呢
    
    1.  首先不建议这么做
    2.  那该怎么做
        
        1.  把子类传递到父类的有参构造中，然后调用
        2.  使用反射的方式调用
        3.  父类调用子类的静态方法
    3.  以上三种方法都是直接调用了子类的方法，好用不？好用。项目里让用不？不允许。
    4.  如果一定要调用子类，那为什么不继承它呢，搞不懂。。。换个角度去理解，父类建立框架，子类在重写了父类的部分方法后再调用父类继承的方法，产生不同的结果--哈哈，这就是模板方法模式的思想。

### 声明 ###

*  摘自秦小波《设计模式之禅》第2版；
 *  仅供学习，严禁商业用途；
 *  代码手写，没有经编译器编译，有个别错误，自行根据上下文改正。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70]: /images/20220602/bda77f4825e74eee8a74328258cb739d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1]: /images/20220602/0a4134418e5f4da79f06cfb2696edef8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2]: /images/20220602/92f91c13c82240eabc9a80e19701a59c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3]: /images/20220602/4a0f233bb7b84adbab6a63f21fd90335.png