详解策略模式

news2025/3/15 11:49:56

引言

实现一个目标往往有多种方式，比如从上海到北京，可以选择高铁、火车、飞机、自驾等等。同样实现一个功能我们可能也有多种方法，把这些方法封装为算法，根据不同的需求选择不同的算法（策略），让功能更加灵活，这就是策略模式的思想。

1.概念

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

2.模式结构

3.模式分析

Context：环境类，是使用算法的角色，它在解决某个问题(即实现某个方法)时可以采用多种策略。在环境类中维持一个对抽象策略类的引用实例，用于定义所采用的策略。核心代码如下：

class Context {

    private AbstractStrategy strategy;//维持一个对抽象策略类的引用



    public void setStrategy(AbstractStrategy strategy) {

        this.strategy = strategy;

    }

    //调用策略类中的算法

    public void algorithm() {

        strategy.algorithm();

    }

}

Strategy：抽象策略类，它为所支持的算法声明了抽象方法，是所有策略类的父类，它可以是抽象类或具体类，也可以是接口。环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。核心代码如下：

public abstract class AbstractStrategy {

    public abstract void algorithm();//声明抽象算法

}

ConcreteStrategy：具体策略类，它实现了在抽象策略类中声明的算法，在运行时，具体策略类将覆盖在环境类中定义的抽象策略类对象，使用一种具体的算法实现某个业务处理。核心代码如下：

class ConcreteStrategyA extends AbstractStrategy {

    //算法的具体实现

    public void algorithm() {

        //算法A

    }

}

4.具体实例分析

这里使用两种算法来实现次幂运算：循环乘法和快速幂（时间复杂度优于循环乘法）。

AbstractOperation：抽象策略类，定义了抽象的计算方法。具体代码如下：

//抽象策略

public abstract class AbstractOperation {

    public abstract double algorithm(double a, int b);

}

MulStrategy：具体策略类，继承抽象策略类，使用了循环乘法来计算次幂，时间复杂度O(n)。具体代码如下：

//具体策略:使用循环乘法计算次幂

class MulStrategy extends AbstractOperation {

    public double algorithm(double a, int b) {

        double num = 1;

        for(int i = 0;i < b;i++){

            num *= a;

        }

        return num;

    }

}

FastPowStrategy：具体策略类，继承抽象策略类，使用了快速幂来计算次幂，时间复杂度O(logn)。快速幂是一种将指数从十进制转化为二进制，从而次幂运算被拆为多个数相乘的形式，从而减少循环层数。具体算法从一个示例来了解一下：

具体代码如下：

//具体策略:使用快速幂算法计算次幂

public class FastPowStrategy extends AbstractOperation{

    public double algorithm(double a, int b) {

        if(a == 0.0f) return 0.0d;

        long num = b;

        if(num < 0){

            num = -num;

            a = 1/a;

        }

        double res = 1.0;

        while(num > 0){

            if((num & 1) == 1) res *= a;

            a *= a;

            num >>= 1;

        }

        return res;

    }

}

PowContext：环境类，内部维持了一个对抽象策略类的引用，并且可以通过这个类选择不同的策略执行计算目标（本质利用了面向对象的多态性）。具体代码如下：

//环境类

class PowContext {

    private AbstractOperation abstractOperation;//维持一个对抽象策略类的引用

    public void setStrategy(AbstractOperation abstractOperation) {

        this.abstractOperation = abstractOperation;

    }

    //调用策略类中的算法

    public double algorithm(double a,int b) {

        return abstractOperation.algorithm(a,b);

    }

}

Client：客户端，分别使用两种策略实现次幂计算。具体代码如下：

public class Client {

    public static void main(String[] args) {

        PowContext pow = new PowContext();

        AbstractOperation fastPowStrategy = new FastPowStrategy();

        AbstractOperation mulStrategy = new MulStrategy();

        double a = 2;

        int b = 3;

        pow.setStrategy(mulStrategy);

        System.out.println("循环乘法:2^3 = " + (pow.algorithm(a,b)));

        pow.setStrategy(fastPowStrategy);

        System.out.println("快速幂:2^3 = " + (pow.algorithm(a,b)));

    }

}

运行代码，结果如下：

5.优缺点

主要优点如下：

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

(2)策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族，恰当使用继承可以把公共的代码移到抽象策略类中，从而避免重复的代码。

(3)策略模式提供了一种可以替换继承关系的办法。如果不使用策略模式，那么使用算法的环境类就可能会有一些子类，每一个子类提供一种不同的算法。但是这样一来算法的使用就和算法本身混在一起，不符合“单一职责原则”，决定使用哪一种算法的逻辑和该算法本身混合在一起，从而不可能再独立演化，而且使用继承无法实现算法或行为在程序运行时的动态切换。

(4)使用策略模式可以避免多重条件选择语句。多重条件选择语句不易维护，它把采取哪一种算法或行为的逻辑与算法或行为本身的实现逻辑混合在一起，将它们全部硬编码(Hard Coding)在一个庞大的多重条件选择语句中，比直接继承环境类的办法还要原始和落后。

(5)策略模式提供了一种算法的复用机制，由于将算法单独提取出来封装在策略类中，因此不同的环境类可以方便地复用这些策略类。

主要缺点如下：

(1)客户端必须知道所有的策略类,并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

(2)策略模式将造成系统产生很多具体策略类，任何细小的变化都将导致系统要增加一个新的具体策略类。

(3)无法同时在客户端使用多个策略类，也就是说,在使用策略模式时，客户端每次只能使用一个策略类，不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。