设计模式—策略模式

最新推荐文章于 2024-11-02 15:00:17 发布

HJXANDHMR

最新推荐文章于 2024-11-02 15:00:17 发布

阅读量292

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/qq_14906597/article/details/51627450

版权

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本博客同步发表在 http://hjxandhmr.github.io/2016/06/10/DesignPattern-Strategy/

今天我们来学习一种行为型模式，策略模式(Observer 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));
    }
}

运行结果

这里写图片描述

模式分析

策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。