🖊策略模式学习笔记

一、简介
二、模式讲解
三、举个例子

一、简介

策略模式（Strategy Pattern）指的是对象具备某个行为，但是在不同的场景中，该行为有不同的实现算法。比如一个人的交税比率与他的工资有关，不同的工资水平对应不同的税率。

策略模式使用的就是面向对象的继承和多态机制，从而实现同一行为在不同场景下具备不同实现。

主要解决

在有多种算法相似的情况下，使用 if...else 或 switch...case 所带来的复杂性和臃肿性。

优点&缺点

优点

算法多样性，且具备自由切换功能；
有效避免多重条件判断，增强了封装性，简化了操作，降低出错概率；
扩展性良好，策略类遵顼里氏替换原则，可以很方便地进行策略扩展；

缺点

策略类数量增多，且所有策略类都必须对外暴露，以便客户端能进行选择；

使用场景

如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
一个系统需要动态地在几种算法中选择一种。
如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项

如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

二、模式讲解

从 UML 类图中，我们可以看到，策略模式主要包含三种角色：

上下文角色（Context）：用来操作策略的上下文环境，屏蔽高层模块（客户端）对策略，算法的直接访问，封装可能存在的变化；
抽象策略角色（Strategy）：规定策略或算法的行为；
具体策略角色（ConcreteStrategy）：具体的策略或算法实现；

以下是 策略模式 的通用代码：

class Client {
    public static void main(String[] args) {
        //选择一个具体策略
        IStrategy strategy = new ConcreteStrategyA();
        //来一个上下文环境
        Context context = new Context(strategy);
        //客户端直接让上下文环境执行算法
        context.algorithm();
    }

    //抽象策略类 Strategy
    interface IStrategy {
        void algorithm();
    }

    //具体策略类 ConcreteStrategy
    static class ConcreteStrategyA implements IStrategy {

        @Override
        public void algorithm() {
            System.out.println("Strategy A");
        }
    }

    //具体策略类 ConcreteStrategy
    static class ConcreteStrategyB implements IStrategy {

        @Override
        public void algorithm() {
            System.out.println("Strategy B");
        }
    }

    //上下文环境
    static class Context {
        private IStrategy mStrategy;

        public Context(IStrategy strategy) {
            this.mStrategy = strategy;
        }

        public void algorithm() {
            this.mStrategy.algorithm();
        }
    }
}

三、举个例子

例子：假设现在有两个数与一个运算符，要求使用该运算符操作这两个数。

分析：直接思路：通过判断运算符符号，对这两个数进行运算。代码如下所示：

    static class Calculator {
        private static final String SYMBOL_ADD = "+";
        private static final String SYMBOL_SUB = "-";

        public int calc(int a, int b, final String symbol) {
            int result = 0;
            if (SYMBOL_ADD.equals(symbol)) {
                result = a + b;
            } else if (SYMBOL_ADD.equals(symbol)) {
                result = a - b;
            }
            return result;
        }
    }

但是这样写的话，如果我们现在要扩展乘法*或除法/运算，那么就要在calc方法内增加对应的if...else判断，代码臃肿并且扩展性太低。
而如果采用策略模式，将各种运算符的计算都归并到对应具体策略，这样，就能简化代码并且带来很好的扩展性，具体代码如下：

class Client {
    public static void main(String[] args) {
        ICalculator calculator = new Add();
        Context context = new Context(calculator);
        int result = context.calc(1,2);
        System.out.println(result);
    }

    interface ICalculator {
        int calc(int a, int b);
    }

    static class Add implements ICalculator {
        @Override
        public int calc(int a, int b) {
            return a + b;
        }
    }

    static class Sub implements ICalculator {
        @Override
        public int calc(int a, int b) {
            return a - b;
        }
    }

    static class Multi implements ICalculator {
        @Override
        public int calc(int a, int b) {
            return a * b;
        }
    }

    static class Divide implements ICalculator {
        @Override
        public int calc(int a, int b) {
            return a / b;
        }
    }

    static class Context {
        private ICalculator mCalculator;

        public Context(ICalculator calculator) {
            this.mCalculator = calculator;
        }

        public int calc(int a, int b) {
            return this.mCalculator.calc(a, b);
        }
    }
}

从上面代码中，我们可以看到，我们完全消除了对运算符号进行判断的哪些if...else的冗余代码，取而代之的是客户端直接决定使用哪种算法，然后交由上下文获取结果。并且上面代码中我们还扩展了乘法Multi和除法Divide运算，所需要做的就只是扩展相应的策略类而已。

原文地址：https://www.cnblogs.com/csh24/p/11813476.html