类图

• Strategy（抽象策略）：抽象策略类，并且定义策略执行入口
• ConcreteStrategy（具体策略）：实现抽象策略，实现algorithm方法
• Context（环境）：运行特定的策略类。

if/else

    public static void main(String[] args) {
        int discountStyle=1;
        if(discountStyle==1)
        {
            System.out.println("执行计价方式1的复杂业务逻辑");
        }
        else if(discountStyle==2)
        {
            System.out.println("执行计价方式2的复杂业务逻辑");
        }
        else if(discountStyle==3)
        {
            System.out.println("执行计价方式3的复杂业务逻辑");
        }
        else {
            System.out.println("执行默认的复杂业务逻辑");
        }
    }

使用策略模式之后

public class strategy {
    public interface DiscountCalculateStrategy
    {
        void calculate();
    }
    public static class DiscountCalculateStrategyA implements DiscountCalculateStrategy
    {

        @Override
        public void calculate() {
            System.out.println("执行计价方式1的复杂业务逻辑");
        }
    }
    public static class DiscountCalculateStrategyB implements DiscountCalculateStrategy
    {

        @Override
        public void calculate() {
            System.out.println("执行计价方式2的复杂业务逻辑");
        }
    }
    public static class DiscountCalculateStrategyC implements DiscountCalculateStrategy
    {

        @Override
        public void calculate() {
            System.out.println("执行计价方式3的复杂业务逻辑");
        }
    }
    public static class DiscountCalculateStrategyD implements DiscountCalculateStrategy
    {

        @Override
        public void calculate() {
            System.out.println("执行默认的复杂业务逻辑");
        }
    }
    public static class DiscountCalculateStrategyFactory{
        public static DiscountCalculateStrategy getDiscountCalculateStrategy(int discountStyle){
            if(discountStyle==1)
            {
                return new DiscountCalculateStrategyA();
            }
            else if(discountStyle==2)
            {
                return new DiscountCalculateStrategyB();
            }
            else if(discountStyle==3)
            {
                return new DiscountCalculateStrategyC();
            }
            else {
                return new DiscountCalculateStrategyD();
            }
        }
    }
    public static class Context{
        private DiscountCalculateStrategy strategy;

        public DiscountCalculateStrategy getStrategy() {
            return strategy;
        }

        public void setStrategy(DiscountCalculateStrategy strategy) {
            this.strategy = strategy;
        }
        public void calculate(){
            strategy.calculate();
        }
    }
    public static void main(String[] args) {
        int discountStyle=1;
        DiscountCalculateStrategy strategy=DiscountCalculateStrategyFactory
                .getDiscountCalculateStrategy(discountStyle);
        Context context=new Context();
        context.setStrategy(strategy);
        context.calculate();
    }
}

要点

1. 必须将if else的代码，封装到不同的策略类中
2. 将选择哪种策略的逻辑给放到一个工厂类中，选择策略的代码务必很简洁
3. context可有可无，具体是看你的策略执行这块如果就一行代码，就不需要contex，如果需要多行就需要设置context

应用场景

主要就是替换掉复杂难懂的if else

和命令模式的区别

• 看起来是一样的，但是用处不一样。
• 命令是可以发送出去的，然后经过一些队列的流转，比如先把命令发送到mq，接着再处理。
• 策略是说选择了一组策略就要立即执行的，不会经过什么别的处理，而且策略逻辑基本就是用在复杂的if else代码中的
• 命令模式可以应用在更多的场景中