设计模式—策略模式

文章目录

1. 1. 模式定义
2. 2. 模式结构
3. 3. UML图
4. 4. 代码实现
   1. 4.1. UML图
   2. 4.2. Strategy.java
   3. 4.3. AddStrategy.java
   4. 4.4. SubStrategy.java
   5. 4.5. MultiStrategy.java
   6. 4.6. DivStrategy.java
   7. 4.7. Calc.java
   8. 4.8. 测试类
   9. 4.9. 运行结果
5. 5. 模式分析
6. 6. 策略模式的优点
7. 7. 策略模式的缺点

今天我们来学习一种行为型模式，策略模式(Strategy Pattern)。

模式定义

定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。

模式结构

策略模式包含如下角色：

Context: 环境类
Strategy: 抽象策略类
ConcreteStrategy: 具体策略类

UML图

代码实现

通常如果一个问题有多个解决方案或者稍有区别的操作时，最简单的方式就是利用if-else or switch-case方式来解决，对于简单的解决方案这样做无疑是比较简单、方便、快捷的，但是如果解决方案中包括大量的处理逻辑需要封装，或者处理方式变动较大的时候则就显得混乱、复杂，而策略模式则很好的解决了这样的问题，它将各种方案分离开来，让操作者根据具体的需求来动态的选择不同的策略方案。 这里以简单的计算操作(+、-、*、/)作为示例：

UML图

Strategy.java

/**
 * 计算操作的抽象
 */
public interface Strategy {
    double calc(double paramA, double paramB);
}

AddStrategy.java

/**
 * 加法的具体实现策略
 */
public class AddStrategy implements Strategy {

    @Override
    public double calc(double paramA, double paramB) {
        System.out.println("Execute AddStrategy");
        return paramA + paramB;
    }
}

SubStrategy.java

/**
 * 减法的具体实现策略
 */
public class SubStrategy implements Strategy {
    @Override
    public double calc(double paramA, double paramB) {
        System.out.println("Execute SubStrategy");
        return paramA - paramB;
    }
}

MultiStrategy.java

/**
 * 乘法的具体实现策略
 */
public class MultiStrategy implements Strategy {
    @Override
    public double calc(double paramA, double paramB) {
        System.out.println("Execute MultiStrategy");
        return paramA * paramB;
    }
}

DivStrategy.java

/**
 * 除法的具体实现策略
 */
public class DivStrategy implements Strategy {
    @Override
    public double calc(double paramA, double paramB) {
        System.out.println("Execute DivStrategy");
        if (paramB == 0) {
            throw new IllegalArgumentException("Cannot divide into 0");
        }
        return paramA / paramB;
    }
}

Calc.java

/**
 * 进行计算操作的上下文环境
 */
public class Calc {

    private Strategy mStrategy;

    public void setStrategy(Strategy strategy) {
        this.mStrategy = strategy;
    }

    public double calc(double paramA, double paramB) {
        if (mStrategy == null) {
            throw new IllegalStateException("You haven't set the strategy for computing.");
        }
        return mStrategy.calc(paramA, paramB);
    }
}

测试类

public class MyClass {

    public double calc(Strategy strategy, double paramA, double paramB) {
        Calc calc = new Calc();
        calc.setStrategy(strategy);
        return calc.calc(paramA, paramB);
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        System.out.println("Calculation Add  " + myClass.calc(new AddStrategy(), 10, 5));
        System.out.println("Calculation Add  " + myClass.calc(new SubStrategy(), 10, 5));
        System.out.println("Calculation Add  " + myClass.calc(new MultiStrategy(), 10, 5));
        System.out.println("Calculation Add  " + myClass.calc(new DivStrategy(), 10, 5));
    }
}

运行结果

模式分析

• 策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。

• 在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。

• 策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。

策略模式的优点

• 策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。

• 策略模式提供了管理相关的算法族的办法。

• 策略模式提供了可以替换继承关系的办法。

• 使用策略模式可以避免使用多重条件转移语句。

策略模式的缺点

• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。

• 策略模式将造成产生很多策略类。

代码已经放到GitHub上了https://github.com/HJXANDHMR/DesignPattern。

参考
http://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/strategy.html

欢迎大家关注我的微信公众号，我会不定期的分享些Android开发的技巧