从零开始学设计模式(十六)：策略模式(Strategy Pattern)

作者的其他平台：

| CSDN：blog.csdn.net/qq\_4115394…

| 掘金：juejin.cn/user/651387…

| 知乎：www.zhihu.com/people/1024…

| GitHub：github.com/JiangXia-10…

| 公众号：1024笔记

本文大概2107字，读完预计需要9分钟

定义

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

策略模式通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。它属于对象行为模式。

可以这么理解：策略就是解决问题的办法。一个问题往往有很多种不同的解决办法，每一种办法就是一种策略了，就好比以前高中的时候解决数学问题，一个题目也可以有很多种解决办法，但是每个人都可以根据一定的因素或者条件来选择不同的策略解决问题。

组成部分

策略模式包含以下三个主要部分：

1、抽象策略类（Strategy）：它主要定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。

2、具体策略类（Concrete Strategy）：它主要就是继承了抽象策略类，并且提供具体的算法实现。

3、环境类（Context）：也叫上下文，起承上启下封装作用，它持有一个策略类的引用，对策略进行二次封装，目的是屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。最终给客户端调用。

例子

上面的介绍完可能还是有点不太好理解，看一个简单的例子，就对策略模式有清晰的认识了。

首先定义一个抽象策略类，定义一个走路的抽象方法：

/**
 * @Author: 江夏
 * @Date: 2021/11/23/21:16
 * @Description:抽象策略类
 */
public abstract class Strategy {
    public abstract void run();
}

接着定义两个具体的策略类继承抽象策略类，并且实现抽象的策略方法：

/**
 * @Author: 江夏
 * @Date: 2021/11/23/21:17
 * @Description:具体策略类1
 */
public class ConcreteStrategy1 extends Strategy {
    @Override
    public void run() {
        System.out.println("具体策略类ConcreteStrategy1跑着走");
    }
}

/**
 * @Author: 江夏
 * @Date: 2021/11/23/21:17
 * @Description:具体策略类2
 */
public class ConcreteStrategy2 extends Strategy {
    @Override
    public void run() {
        System.out.println("具体策略类ConcreteStrategy2慢悠悠地走");
    }
}

接着就是上下文context类：

/**
 * @Author: 江夏
 * @Date: 2021/11/23/21:18
 * @Description:上下文类
 */
public class Context {
    public Strategy strategy;

    //构造函数
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void process(){
        strategy.run();
    }
}

最后再来一个测试方法：

/**
 * @Author: 江夏
 * @Date: 2021/11/23/21:20
 * @Description:测试方法
 */
public class StrategyPatternTest {
    public static void main(String[] args) {
        Context context = null;
        System.out.println("策略一");
        context = new Context(new ConcreteStrategy1());
        context.process();

        System.out.println("策略二");
        context = new Context(new ConcreteStrategy2());
        context.process();
    }
}

运行结果如下：

看完了案例，可能会觉得这不是前一篇的模版方法模式吗？其实策略模式和模版方法模式很相似。

策略模式与模版方法模式的区别仅仅是多了一个单独的上下文类Context。在模版方法模式中，调用算法的主体在抽象的父类中，而在策略模式中，调用算法的主体则是封装到了上下文Context类中，抽象策略类只是为了定义规范，里面一般不包含逻辑。策略模式中加了上下文类，通过上下类调用方法，屏蔽了直接对具体实现的访问，更符合面向对象的原则。

策略模式的优点

1、策略类之间可以自由切换，由于策略类实现自同一个抽象，所以他们之间可以自由切换。

2、易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展，只需要新增一个类就可以了。

策略模式的缺点

1、策略模式易于拓展的后果就是维护各个策略类会给开发带来额外开销，每一个策略都是一个类，复用的可能性很小、类数量增多。

2、所有的策略类都需要对外暴露，因为使用哪种策略是由客户端来决定的。违背了迪米特法则。

应用场景

策略模式实质上就是面向对象中的继承和多态，使用策略模式的场景很多，而且在很多应用的场景中，在策略模式中一般会看到模版方法模式的影子，所以策略模式的应用场景和模版方法基本差不多，比如：

1、如果代码中几个类的主要逻辑相同，只在部分逻辑的算法和行为上有一些区别；

2、有几种相似的逻辑，但是需要由客户端动态地决定使用哪一种；

总结

策略模式是一种简单并且常用的模式，它主要就一个算法抽象类或者接口封装算法、然后多个具体的算法实现类实现它的方法再被一个上下文类来包装一下。一般来说，策略模式不会单独使用，跟模版方法模式、工厂模式等混合使用的情况比较多。

本文以及之前的所有的设计模式中的例子代码，都将同步至github，需要的欢迎下载star！

github地址：github.com/JiangXia-10…

相关推荐：

从零开始学设计模式(一)：什么是设计模式

从零开始学设计模式(二)：单例模式

从零开始学设计模式(三)：原型模式(Prototype Pattern)

从零开始学设计模式(四)：工厂模式（Factory Pattern）

从零开始学设计模式(五)：建造者模式(Builder Pattern)

从零开始学设计模式(六)：适配器模式（Adapter Pattern）

从零开始学设计模式(六)：代理模式（Proxy Pattern）

从零开始学设计模式(八)：装饰器模式(Decorator Pattern)

从零开始学设计模式(九)：外观模式（Facade Pattern）

从零开始学设计模式(十)：桥接模式（Bridge Pattern）

从零开始学设计模式(十一)：组合模式(Composite Pattern)

从零开始学设计模式(十二)：享元模式（Flyweight Pattern）

从零开始学设计模式(十三)：访问者模式（Visitor Pattern）

从零开始学设计模式(十四)：中介者模式（Mediator Pattern）

从零开始学设计模式(十五)：模版方法模式（Template Method Pattern）