23种设计模式之策略模式（Strategy Pattern）

前言：大家好，我是小威，24届毕业生，在一家满意的公司实习。本篇文章将23种设计模式中的策略模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
如果文章有什么需要改进的地方还请大佬不吝赐教👏👏。
小威在此先感谢各位大佬啦~~🤞🤞

🏠个人主页：小威要向诸佬学习呀
🧑个人简介：大家好，我是小威，一个想要与大家共同进步的男人😉😉
目前状况🎉：24届毕业生，在一家满意的公司实习👏👏

💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬😘

以下正文开始

策略模式概念

策略模式（Strategy Pattern）是一种行为型设计模式，它允许在运行时动态改变对象的行为。策略模式优先考虑将算法、业务规则等抽象成不同的类，从而可以通过组合实现各种功能和应用场景。

策略模式角色

策略模式通常包括以下几个角色：

策略接口（Strategy Interface）：定义了所有具体策略类都需要实现的方法或者属性等，包括上下文可以调用的所有操作。

具体策略类（Concrete Strategy Class）：实现了策略接口中定义的所有方法，并且封装了一个特定的算法、业务规则等。

上下文类（Context Class）：包含着与具体策略类相关联的数据，并控制着具体策略类的初始化、调用、切换等操作。

在使用策略模式时，我们通常将具体策略类定义为独立的类或者匿名内部类，以便于后期对其进行扩展和维护。同时，我们还可以提供一些工厂模式和单例模式等去创建和管理具体策略类，并使用IOC容器来统一管理上下文类和具体策略类的生命周期等。

策略模式优缺点

策略模式的优点包括：

1. 可以动态切换具体策略类，不需要修改上下文类的代码，提高了代码的灵活性和可维护性。

2. 可以避免使用复杂的条件语句或者多层嵌套等，提高了代码的可读性和易用性。

3. 可以使算法、业务规则等更加独立和可测试，从而降低了耦合性和复杂度。

策略模式的缺点包括：

1. 需要定义和管理大量的具体策略类，增加了代码量和维护难度。

2. 如果策略接口较为复杂或者需要频繁调整，可能会导致系统性能下降。

策略模式代码案例

我们使用一个简单的例子来介绍下策略模式：

首先，我们需要定义一个策略接口（Strategy Interface），其中包含了所有具体策略类都需要实现的方法：

public interface Strategy {
    int calculate(int a, int b);
}
1
2
3

然后，我们可以定义几个具体策略类（Concrete Strategy Class），它们分别对应不同的算法、业务规则等：

public class AddStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class SubtractStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}

public class MultiplyStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a * b;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

接下来，我们需要定义一个上下文类（Context Class），它通过组合具体策略类实现不同的功能：

public class Context {
    private Strategy strategy;

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

    public int executeStrategy(int a, int b) {
        return strategy.calculate(a, b);
    }
}
1
2
3
4
5
6
7
8
9
10
11

最后，我们可以通过如下方式使用策略模式：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        Context context = new Context();

        Strategy addStrategy = new AddStrategy();
        context.setStrategy(addStrategy);
        int result1 = context.executeStrategy(a, b);
        System.out.println(a + " + " + b + " = " + result1);

        Strategy subtractStrategy = new SubtractStrategy();
        context.setStrategy(subtractStrategy);
        int result2 = context.executeStrategy(a, b);
        System.out.println(a + " - " + b + " = " + result2);

        Strategy multiplyStrategy = new MultiplyStrategy();
        context.setStrategy(multiplyStrategy);
        int result3 = context.executeStrategy(a, b);
        System.out.println(a + " * " + b + " = " + result3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行我们的代码，输出结果如下：

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
1
2
3

在上面的例子中，我们通过策略模式实现了对不同算法的封装和组合，从而实现了更灵活、易维护的代码设计。

策略模式小结

总之，策略模式通常适用于将相似但不同的算法、业务规则等进行封装和组合的应用场景，它通过分离算法、封装变化、抽象依赖等方式，实现了代码的扩展性和重用性。

好了，本篇文章就先分享到这里了，后续将会继续介绍23种设计模式之其他模式，感谢大佬认真读完支持咯~

文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起讨论😁
希望能和诸佬们一起努力，今后我们顶峰相见🍻
再次感谢各位小伙伴儿们的支持🤞