场景： （1）我们有多种优惠策略 （2）不同的优惠策略在计算的价格的时候，有一些通用的基础逻辑 （3）每种优惠策略还有一些是自己特殊的价格计算的逻辑

1.常规

package com.example.demo.pattern.template;
/**
 * 不用模式的实现
 * @author chenchao
 *
 */
public class WithoutTempalteMethodPatternDemo {
    public static void main(String[] args) {
        DiscountCalculator1 calculator1 = new DiscountCalculator1();
        calculator1.calculate();
        DiscountCalculator2 calculator2 = new DiscountCalculator2();
        calculator2.calculate();
        DiscountCalculator3 calculator3 = new DiscountCalculator3();
        calculator3.calculate();
        // 有一个问题
        // 就是说，这个三种优惠方式计算器里面，都有一段通用的计算逻辑，是完全相同的代码
        // 但是相同的一段代码，给通过复制粘贴的方式，放到了不同的类里去
        // 一旦说，那段通用的计算逻辑，要修改，就涉及到多个类都要去修改那个代码
        // 如果你一旦忘了修改某个类中的那段代码，后果不堪设想
        // 而且到了后期，几乎没人记得清楚，那段通用逻辑代码放在了多少个类中，如果要排查，需要将很多类重新读一遍代码
        // 这就是垃圾代码，扩展性，维护性，很烂
    }
    public static class DiscountCalculator1 {
        public void calculate() {
            System.out.println("通用的计算逻辑，修改了一下");
            System.out.println("优惠计算器1的特殊计算逻辑");  
        }
    }
    public static class DiscountCalculator2 {
            public void calculate() {
                System.out.println("通用的计算逻辑，修改了一下");
                System.out.println("优惠计算器2的特殊计算逻辑");  
            }
        }
    public static class DiscountCalculator3 {
        public void calculate() {
            System.out.println("通用的计算逻辑");
            System.out.println("优惠计算器3的特殊计算逻辑");  
        }
    }
}

2.模板模式

package com.example.demo.pattern.template;
/**
 * 使用了模板方法模式
 *
 * @author chenchao
 */
public class TemplateMethodPatterDemo {
    public static void main(String[] args) {
        DiscountCalculator calculator1 = new DiscountCalculator1();
        calculator1.calculate();
        DiscountCalculator calculator2 = new DiscountCalculator2();
        calculator2.calculate();
        DiscountCalculator calculator3 = new DiscountCalculator3();
        calculator3.calculate();
    }
    public interface DiscountCalculator {
        void calculate();
    }
    /**
     * 模板方法实现的精华所在
     *
     * @author chenchao
     */
    public static abstract class AbstractDiscountCalculator implements DiscountCalculator {
        @Override
        public void calculate() {
            // 完成通用的计算逻辑
            commonCalculate();
            // 完成特殊的计算逻辑
            specificCalculate();
        }
        private void commonCalculate() {
            System.out.println("通用的计算逻辑，修改了一下");
        }
        protected abstract void specificCalculate();
    }
    public static class DiscountCalculator1 extends AbstractDiscountCalculator {
        @Override
        public void specificCalculate() {
            System.out.println("优惠计算器1的特殊计算逻辑");
        }
    }
    public static class DiscountCalculator2 extends AbstractDiscountCalculator {
        @Override
        public void specificCalculate() {
            System.out.println("优惠计算器2的特殊计算逻辑");
        }
    }
    public static class DiscountCalculator3 extends AbstractDiscountCalculator {
        @Override
        public void specificCalculate() {
            System.out.println("优惠计算器3的特殊计算逻辑");
        }
    }
}

3.说明

常用模式之一，对于我们而言喜欢把通用逻辑封装成一个方法，需要用到就引用。相比模板设计模式基于抽象类设计把通用逻辑放到抽象类，每个实现都集成他，这样可读性很好，很好维护，相对于增加代码量扩展性，可读性更好。