Java 策略模式和模板方法模式

package com.example.demo.design;

/**
 * 策略模式:设计一个接口或抽象类，声明一个或多个方法，多个类实现这个接口，再设计一个上下文类又称环境类，起承上启下封装作用，
 * 类里声明一个该接口成员变量，上下文类的构造方法或set方法注入该接口的实现类，在这个类的某个方法里会调用接口的方法
 */

/**
 * 策略模式和模板方法模式：模板方法模式定义了骨架，变化的是骨架中部分的特定内容
 *                      策略模式是在上下文类中自定义流程，变化的是整个流程，模板方法的整个流程是固定的。
 */
public class Strategy {
    A a;

    // 1.通过构造方法注入
    public Strategy() {
        a = new C();
    }

    // 2.通过set方法注入
    public void setA(A a) {
        this.a = a;
    }

    public void logic() {
        // 3.手动new
        A a = new B();
        if (a != null) {
            a.method();
        }
    }

    public static abstract class A {
        // 可以有多套算法，分为A、B组
        public abstract void method();
    }

    public static class B extends A {
        @Override
        public void method() {
            System.out.println("B.impl");
        }
    }

    public static class C extends A {

        @Override
        public void method() {
            System.out.println("C.impl");
        }
    }
}

package com.example.demo.design;

/**
 * 模板方法模式:设计一个抽象父类，父类中定义了主要的逻辑方法和数据结构，扩展定义多个子类继承抽象父类，
 * 子类重写(@Override)父类的protected修饰的抽象方法，根据业务需求的变化实现这些抽象方法，但大致的代码逻辑由抽象父类定义，
 * 符合开闭原则（封装不变部分，扩展可变部分）
 */
public abstract class StrategyTemplate {
    private String a = getA();
    protected String b;

    // 钩子函数，变化部分由子类实现
    protected abstract String getA();
    protected abstract void method1();
    protected abstract void method2();
    // 主要逻辑由父类实现
    // 模板方法模式只针对一套算法
    public void method() {
        // logic
        method1();
        method2();
        // ...
    }
    
}

class A extends StrategyTemplate {

    @Override
    protected String getA() {
        return "abc";
    }

    @Override
    protected void method1() {
        System.out.println("A.method1()");
    }

    @Override
    protected void method2() {
        System.out.println("A.method2()");
    }
}

class B extends StrategyTemplate {

    @Override
    protected String getA() {
        return "def";
    }

    @Override
    protected void method1() {
        System.out.println("B.method1()");
    }

    @Override
    protected void method2() {
        System.out.println("B.method2()");
    }
}

class Test {
    public static void main(String[] args) {
        StrategyTemplate st = new A();
        st.method();
        st = new B();
        st.method();
    }
}