当前位置：首页 > news >正文

设计模式使用场景实现示例及优缺点（行为型模式——策略模式）

news 2026/2/9 3:22:43

在遥远的王国里，有三个重要的角色：国王策略模式、他的皇家顾问算法家族，以及年轻的骑士接口。国王策略模式统治着整个王国，他的职责是确保每一个编程问题都能找到最合适的解决方案。

有一天，王国遇到了一场危机。编程王国中的一条巨龙，名叫“复杂性”，不断地改变自己的形态和行为，让程序员们疲于应对。面对这种情况，国王策略模式召集了他的皇家顾问算法家族。

算法家族中的成员包括快排骑士、归并骑士和冒泡骑士，他们每一个都有独特的技能和解决问题的方法。国王策略模式知道，这些骑士们的力量需要得到充分发挥，但他们的行动必须有组织、有协调。

于是，国王策略模式召见了年轻的骑士接口。接口骑士是一个精通沟通与协调的角色，他能让不同的算法骑士在合适的时候出场，发挥各自的优势。

策略模式国王说：“年轻的接口骑士，你需要创建一个共同的接口，让所有的算法骑士都能遵循这个接口来行动。这样一来，我们就能在遇到不同情况时，根据需要选择最适合的骑士出战。”

接口骑士接受了任务，开始设计一个通用的接口。这个接口规定了所有算法骑士必须遵循的方法和行为。无论是快排骑士、归并骑士还是冒泡骑士，他们都必须实现这个接口，确保可以被无缝调用和替换。

很快，接口设计完成了，算法家族的每个成员都被重新训练，适应新的接口。这样一来，当巨龙复杂性再次来袭时，接口骑士可以迅速选择合适的算法骑士来对抗它。

例如，当龙表现出需要快速排序的特性时，接口骑士会召唤快排骑士；当巨龙需要稳定排序时，接口骑士会召唤归并骑士；而当情况简单时，冒泡骑士便会上场。

通过创建一个共同的接口，将不同的算法封装成独立的类，并使它们之间可以相互替换。

策略模式（Strategy Pattern）

策略模式（Strategy Pattern）是一种行为设计模式，它能够在运行时选择最适合的算法或行为，同时能够将算法族封装成独立的类，并使它们之间可以相互替换。这种模式是通过创建一个共同的接口，而后将不同的行为或算法封装在不同的策略类中实现的。每个策略类都遵循相同的接口，从而保持策略的独立性与互换性。

核心组件

Strategy（策略接口）：这是一个共同的接口，它定义了所有支持的算法的抽象方法。任何具体策略都必须实现这个接口。
ConcreteStrategy（具体策略）：实现策略接口的类，提供具体的算法实现。
Context（上下文）：用来维护对策略对象的引用，它可以定义一个接口，让策略对象根据上下文来选择适当的算法。

适用场景

多种算法或行为：
- 当一个类存在多种行为，且使用条件时，可以将这些行为封装成不同的策略。
避免使用多重条件选择语句：
- 使用策略模式可以避免使用多重条件选择语句，这样可以更容易维护和扩展。
需要动态地改变算法或行为：
- 当算法或行为需要经常改变时，使用策略模式可以提供更好的代码组织和重新使用。
行为变化独立于使用行为的客户：
- 需要将行为与客户代码解耦，使得行为的改变不会影响客户代码。

实现实例

以电商系统的支付功能为例，假设需要支持多种支付方式（如信用卡、PayPal、比特币等）。使用策略模式可以定义一个支付接口（PaymentStrategy），并为每种支付方式实现一个具体的策略类。上下文（PaymentContext）可以持有一个支付策略引用，根据不同的用户选择使用不同的支付策略：

策略接口（Strategy Interface）

这个接口定义了所有支持的算法或行为的抽象方法。每个具体的策略类都必须实现这个接口。

public interface PaymentStrategy {void pay(int amount);  // 定义支付行为的方法，每种支付策略都需要实现这个方法
}

具体策略类（Concrete Strategy Classes）

这些类实现了策略接口，并提供了具体的算法实现。

public class CreditCardStrategy implements PaymentStrategy {public void pay(int amount) {System.out.println("Paid " + amount + " using Credit Card");  // 信用卡支付实现}
}public class PayPalStrategy implements PaymentStrategy {public void pay(int amount) {System.out.println("Paid " + amount + " using PayPal");  // PayPal支付实现}
}public class BitcoinStrategy implements PaymentStrategy {public void pay(int amount) {System.out.println("Paid " + amount + " using Bitcoin");  // 比特币支付实现}
}

上下文类（Context Class）

这个类用于维护对策略对象的引用。它可以定义一个方法让策略对象根据上下文来选择适当的算法。

public class PaymentContext {private PaymentStrategy strategy;  // 维护一个对策略对象的引用public PaymentContext(PaymentStrategy strategy) {this.strategy = strategy;  // 构造函数中设置策略对象}public void setStrategy(PaymentStrategy strategy) {this.strategy = strategy;  // 允许在运行时改变策略}public void executePayment(int amount) {strategy.pay(amount);  // 执行支付，具体行为取决于策略对象}
}

客户端代码（Client Code）

这部分代码演示了如何使用策略模式来改变对象的行为。

public class Client {public static void main(String[] args) {PaymentContext context = new PaymentContext(new CreditCardStrategy());context.executePayment(100);  // 使用信用卡策略支付100context.setStrategy(new PayPalStrategy());context.executePayment(200);  // 更改策略为PayPal并支付200context.setStrategy(new BitcoinStrategy());context.executePayment(300);  // 更改策略为比特币并支付300}
}

优缺点

优点

封装性好：
- 策略模式将每个变化的策略封装到独立的类中，使得每个策略可以独立于客户端实现变化。
易于扩展：
- 策略模式提供了一种扩展机制，新的策略类可以很容易地添加进现有系统中。
避免使用多重条件选择语句：
- 策略模式允许动态地改变行为，客户端仅需更改配置，无需修改代码。

缺点

客户端必须知道所有策略：
- 客户端需要了解所有的策略类，并自行决定使用哪一个策略类。
策略族的增多：
- 随着策略族的增加，各种策略类的数目也会增加，每个策略都需要对外暴露，这就增加了系统的复杂性。

类图

+----------------+         +------------------+
|     Context    |-------->|     Strategy     |
+----------------+         +------------------+
| - strategy:    |         | + execute()      |
|   Strategy     |         +------------------+
| + setStrategy()|                 ^
| + execute()    |                 |
+----------------+                 ||+-------------------+--------+--------+----------------+|                   |                 |                |
+---------------+ +-----------------+ +----------------+ +--------------+
|ConcreteStrategyA| |ConcreteStrategyB| |ConcreteStrategyC| | ...          |
+---------------+ +-----------------+ +----------------+ +--------------+
| + execute()   | | + execute()     | | + execute()    | | + execute()   |
+---------------+ +-----------------+ +----------------+ +--------------+

总结

策略模式提供了一种灵活的方式来切换对象的行为，增强了代码的可维护性和扩展性。它帮助将行为封装为对象，可以在运行时互换，这使得它在需要支持多种行为的系统中非常有用。这种模式特别适合于那些算法或行为多样化的场景，可以有效地帮助系统遵守开闭原则，即对扩展开放，对修改关闭。通过策略模式，程序员可以方便地添加新的策略而不影响现有的系统，并且能够在运行时动态地改变对象的行为。