template method模式

场景：

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

1、不使用模板方法时的到处粘贴复制的辣鸡代码

/**
 * 不使用模板方法模式
 */
public class WithoutTemplateMethodPatternDemo {

    /**
     * 有一个问题
     * 就是说，这个三种优惠方式的计算器里面，都有一段通用的计算逻辑，是完全相同的代码
     * 但是相同的一段代码，给通过复制粘贴的方式，放到了不同的类里去
     * 一旦说，那段通用的计算逻辑，要修改，就涉及到多个类都要去修改那个代码
     * 如果你一旦忘了修改某个类中的那段代码，后果不堪设想
     * 而且到了后期，几乎没人记得清楚，那段通用逻辑代码放在了多少个类中了，如果要排查，
     * 需要将很多类重新读一遍代码
     * 这就是辣鸡代码，可扩展性，维护性，很烂
     */
    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、使用模板方法设计模式相同的部分只出现一次

/**
 * 使用了模板方法模式
 */
public class TemplateMethodPatternDemo {

    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 interface DiscountCalculator{
        void calculate();
    }

    /**
     * 模板方法实现的精华所在
     */
    public static abstract class AbstractDiscountCalculator implements DiscountCalculator{

        @Override
        public void calculate(){
            //完成通用的计算逻辑
            commonCalculate();
            //完成特殊的计算逻辑
            specificCalculate();
        }

        private void commonCalculate() {
            System.out.println("通用的计算逻辑");
        }

        protected abstract void specificCalculate();
    }

       // 模板子类1
    public static class DiscountCalculator1 extends AbstractDiscountCalculator{

        @Override
        protected void specificCalculate() {
            System.out.println("优惠计算器 1 的特殊计算逻辑");
        }

    }

     // 模板子类2
    public static class DiscountCalculator2 extends AbstractDiscountCalculator {

        @Override
        protected void specificCalculate() {
            System.out.println("优惠计算器 2 的特殊计算逻辑");
        }
    }

       // 模板子类3
    public static class DiscountCalculator3 extends AbstractDiscountCalculator{

        @Override
        protected void specificCalculate() {
            System.out.println("优惠计算器 3 的特殊计算逻辑");
        }
    }

}

这个模式一定要多用用，尤其是对于有多种不同实现的一些场景，比如说，不同的折扣类型，不同的优惠券类型，不同的商品类型，那肯定涉及到不同的处理逻辑。

但是可以将他们共同的基础逻辑抽取到父类中，然后将要子类实现的逻辑留空，交给子类去实现。