Java 设计模式之模板方法模式（Template Method）

古城微笑少年丶 2022-02-21 13:53 212阅读 0赞

**目录**

模板方法模式（Template Method）

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

# 模板方法模式（Template Method） #

1、模板方法模式：指一个抽象类中，有一个非抽象的主方法，和其它抽象或非抽象的辅助方法，再定义一个子类，继承该抽象类，重写其抽象方法（或子类需要重写的其它方法），通过调用抽象类的主方法，实现对子类的方法调用。

2、关系图如下：

![20190411083504529.png][]

> 在 AbstractCalculator 抽象类中定义一个主方法 calculate（非抽象），calculate() 调用其它辅助方法如 spilt() 等（也可以不调用），Plus（加法） 和 Minus （减法）分别继承 AbstractCalculator 类，通过对 AbstractCalculator 的调用实现对子类的调用。

3、下面使用代码来实现上图（本示例纯粹为演示模式的思想和设计）：

package main.templateMethod;
    
    import java.util.logging.Logger;
    
    //抽象类
    public abstract class AbstractCalculator {
    
        /**
         * 抽象类中的主方法。设计成 final ，子类无法继承。calculate：计算
         *
         * @param a
         * @param b
         * @return
         */
        public final float calculate(String a, String b) {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("用户请求计算：a=" + a + "，b=" + b);
    
            float[] floats = check(a, b);
            //子类会重写下面的 calculate(int a, int b) 方法，所以这里调用其实是子类的方法
            return calculate(floats[0], floats[1]);
        }
    
        /**
         * a 、b 不能为 null；不能为空；必须是数字格式，不能是非法的其它字符，如 zbc123
         *
         * @param a
         * @param b
         * @return
         */
        public float[] check(String a, String b) {
            float[] floats = new float[2];
            if (a != null && !"".equals(a) && a.matches("-?\\d+.?\\d+")) {
                floats[0] = Float.parseFloat(a);
            } else {
                throw new RuntimeException("参数 " + a + " 为非法数字...");
            }
            if (b != null && !"".equals(b) && b.matches("-?\\d+.?\\d+")) {
                floats[1] = Float.parseFloat(b);
            } else {
                throw new RuntimeException("参数 " + b + " 为非法数字...");
            }
            return floats;
        }
    
        //需要子类重写的方法，这里重载了上面的 calculate(String a, String b)
        public abstract float calculate(float a, float b);
    
    }

4、下面是两个子类：

package main.templateMethod;
    
    import java.util.logging.Logger;
    
    public class Plus extends AbstractCalculator {
        @Override
        public float calculate(float a, float b) {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("加法运算：" + a + " + " + b);
            return a + b;
        }
    }

package main.templateMethod;
    
    import java.util.logging.Logger;
    
    public class Minus extends AbstractCalculator {
        @Override
        public float calculate(float a, float b) {
            Logger logger = Logger.getAnonymousLogger();
            logger.info("减法运算：" + a + " - " + b);
            return a - b;
        }
    }

5、测试如下：

package main.test;
    
    import main.templateMethod.AbstractCalculator;
    import main.templateMethod.Minus;
    import main.templateMethod.Plus;
    
    import java.util.logging.Logger;
    
    public class Test {
        public static void main(String[] args) {
            Logger logger = Logger.getAnonymousLogger();
    
            AbstractCalculator calculator_plus = new Plus();
            float result1 = calculator_plus.calculate("25", "50.55");
            logger.info("result1=" + result1);
    
    
            AbstractCalculator calculator_minus = new Minus();
            float result2 = calculator_minus.calculate("120.55", "-40");
            logger.info("result2=" + result2);
    
            calculator_minus.calculate("120.55", "-40xx");//故意设置为非法字符
        }
    }

![20190411093005267.gif][]

> 实际应用中并不会这么来进行计算操作，但这只是纯粹演示模板方法模式的用法，从父类调用子类。

[20190411083504529.png]: /images/20220221/a3c442e00e00444685ebd57b390583bf.png
[20190411093005267.gif]: /images/20220221/a36fcaa11349448797ba30b113b76327.png