【设计模式】策略模式你真的掌握了吗？

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化不会影响到使用算法的客户。它通过组合而非继承来实现算法的多样化和灵活性。本文将详细介绍策略模式的概念、结构、实现方法及其优缺点，并通过实例展示其应用。

策略模式的结构

策略模式的结构主要包括以下几个角色：

1. 策略接口（Strategy）：定义算法的接口。
2. 具体策略（ConcreteStrategy）：实现策略接口的具体算法。
3. 上下文（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

策略模式的优缺点

优点

1. 开闭原则：可以在不修改原有代码的情况下引入新的策略。
2. 避免使用多重条件判断：通过使用策略模式，可以避免在代码中使用大量的 if-else 或 switch-case 语句。
3. 提高算法的可复用性：每个策略实现都可以独立复用。

缺点

1. 增加对象数量：每个具体策略都需要一个类，可能会导致类的数量增加。
2. 客户端必须了解所有策略：客户端需要知道所有可用的策略，才能选择合适的策略。

应用场景

策略模式适用于以下场景：

1. 需要在运行时选择算法的场景：如排序算法、加密算法等。
2. 算法需要灵活切换的场景：如支付方式（信用卡、现金、支付宝等）。
3. 避免使用多重条件判断的场景：如不同会员等级的折扣策略。

实例应用

以下是一个简单的实例应用，展示如何使用策略模式实现支付方式的选择。

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

策略模式通过定义一系列算法并将每个算法封装起来，使得算法可以相互替换，从而实现算法的灵活切换和复用。本文详细介绍了策略模式的概念、结构、实现方法及其优缺点，并通过实例展示了其应用。希望本文能够帮助你更好地理解和应用策略模式，提高代码的可维护性和可扩展性。