策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化不会影响到使用算法的客户。它通过组合而非继承来实现算法的多样化和灵活性。本文将详细介绍策略模式的概念、结构、实现方法及其优缺点，并通过实例展示其应用。
策略模式的结构
策略模式的结构主要包括以下几个角色：
- 策略接口（Strategy）：定义算法的接口。
- 具体策略（ConcreteStrategy）：实现策略接口的具体算法。
- 上下文（Context）：使用策略的环境类，维护一个策略对象，并可以在运行时动态更换策略。
策略模式的实现
以下是使用 Java 实现策略模式的详细代码示例。
1. 定义策略接口
策略接口定义了算法的方法。
public interface Strategy {
int doOperation(int num1, int num2);
}
2. 实现具体策略类
具体策略类实现了策略接口，提供具体的算法实现。
public class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
public class OperationSubtract implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
public class OperationMultiply implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 * num2;
}
}
3. 定义上下文类
上下文类使用一个策略对象，可以动态地更换策略。
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}
4. 测试策略模式
在客户端代码中使用策略模式选择和执行不同的算法。
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context.setStrategy(new OperationSubtract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context.setStrategy(new OperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
运行结果：
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
策略模式的优缺点
优点
- 开闭原则：可以在不修改原有代码的情况下引入新的策略。
- 避免使用多重条件判断：通过使用策略模式，可以避免在代码中使用大量的 if-else 或 switch-case 语句。
- 提高算法的可复用性：每个策略实现都可以独立复用。
缺点
- 增加对象数量：每个具体策略都需要一个类，可能会导致类的数量增加。
- 客户端必须了解所有策略：客户端需要知道所有可用的策略，才能选择合适的策略。
应用场景
策略模式适用于以下场景：
- 需要在运行时选择算法的场景：如排序算法、加密算法等。
- 算法需要灵活切换的场景：如支付方式（信用卡、现金、支付宝等）。
- 避免使用多重条件判断的场景：如不同会员等级的折扣策略。
实例应用
以下是一个简单的实例应用，展示如何使用策略模式实现支付方式的选择。
1. 定义支付策略接口
public interface PaymentStrategy {
void pay(int amount);
}
2. 实现具体支付策略类
public class CreditCardPayment implements PaymentStrategy {
private String cardNumber;
public CreditCardPayment(String cardNumber) {
this.cardNumber = cardNumber;
}
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using Credit Card " + cardNumber);
}
}
public class PaypalPayment implements PaymentStrategy {
private String email;
public PaypalPayment(String email) {
this.email = email;
}
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using PayPal " + email);
}
}
3. 定义上下文类
public class PaymentContext {
private PaymentStrategy paymentStrategy;
public PaymentContext(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void pay(int amount) {
paymentStrategy.pay(amount);
}
}
4. 测试策略模式
public class StrategyPatternPaymentDemo {
public static void main(String[] args) {
PaymentContext context = new PaymentContext(new CreditCardPayment("1234-5678-9876-5432"));
context.pay(100);
context.setPaymentStrategy(new PaypalPayment("example@example.com"));
context.pay(200);
}
}
运行结果：
Paid 100 using Credit Card 1234-5678-9876-5432
Paid 200 using PayPal example@example.com
策略模式通过定义一系列算法并将每个算法封装起来，使得算法可以相互替换，从而实现算法的灵活切换和复用。本文详细介绍了策略模式的概念、结构、实现方法及其优缺点，并通过实例展示了其应用。希望本文能够帮助你更好地理解和应用策略模式，提高代码的可维护性和可扩展性。
