Java 策略模式（ Strategy Pattern）详解

说明：

策略模式是一种行为型设计模式，它允许你定义一组算法，将每个算法封装为独立的类，并使它们可以互相替换。它使得算法的实现能够独立于使用它的客户端。

在Java中，策略模式通常涉及以下组件：

1. 上下文（Context）：这是包含算法的类，并提供一种设置所需策略的方式。上下文类负责通过委托工作给选定的策略来执行算法。

2. 策略（Strategy）：这是一个接口或抽象类，定义了算法的契约。它声明了所有具体策略必须实现的公共方法。

3. 具体策略（Concrete Strategies）：这些是实现策略接口的类。每个具体策略封装了上下文可以使用的特定算法。

策略模式的关键思想是封装可替换的算法，并提供一种在运行时动态切换它们的方式。这使得代码更加灵活和可扩展。客户端代码可以与上下文对象交互，而无需了解具体的算法实现。

翻译：

The Strategy pattern is a behavioral design pattern that allows you to define a family of algorithms, encapsulate each one as a separate class, and make them interchangeable. It lets the algorithm vary independently from clients that use it.

In the context of Java, the Strategy pattern typically involves the following components:

1. Context: This is the class that contains the algorithm and provides a way to set the desired strategy. The context class is responsible for executing the algorithm by delegating the work to the selected strategy.

2. Strategy: This is an interface or an abstract class that defines the contract for the algorithm. It declares the common method(s) that all concrete strategies must implement.

3. Concrete Strategies: These are the classes that implement the Strategy interface. Each concrete strategy encapsulates a specific algorithm that the context can use.

The key idea behind the Strategy pattern is to encapsulate alternative algorithms and provide a way to dynamically switch between them at runtime. This allows for more flexibility and extensibility in your code. The client code can interact with the context object without knowing the specific algorithm implementation.

下面是一个用Java示例来说明策略模式：

// 策略接口
interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略
class CreditCardStrategy implements PaymentStrategy {
    private String cardNumber;
    private String expiryDate;
    private String cvv;

    public CreditCardStrategy(String cardNumber, String expiryDate, String cvv) {
        this.cardNumber = cardNumber;
        this.expiryDate = expiryDate;
        this.cvv = cvv;
    }

    public void pay(double amount) {
        System.out.println("使用信用卡支付 " + amount);
        // 执行实际的信用卡支付逻辑
    }
}

class PayPalStrategy implements PaymentStrategy {
    private String email;
    private String password;

    public PayPalStrategy(String email, String password) {
        this.email = email;
        this.password = password;
    }

    public void pay(double amount) {
        System.out.println("使用PayPal支付 " + amount);
        // 执行实际的PayPal支付逻辑
    }
}

// 上下文
class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double totalAmount) {
        // 计算总金额并执行必要的处理

        // 委托选定的策略进行支付
        paymentStrategy.pay(totalAmount);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // 根据用户输入动态设置支付策略
        PaymentStrategy paymentStrategy = new CreditCardStrategy("123456789", "12/23", "123");
        cart.setPaymentStrategy(paymentStrategy);

        // 执行结账
        cart.checkout(100.0);
    }
}

以上示例展示了策略模式的用法。PaymentStrategy接口定义了支付策略的契约，CreditCardStrategy和PayPalStrategy是具体的策略实现类。ShoppingCart作为上下文类，通过setPaymentStrategy方法设置支付策略，然后调用checkout方法执行结账操作，委托所选的策略进行支付。

通过策略模式，我们可以根据需要动态选择不同的支付策略，而不需要直接依赖于具体的支付逻辑。这种灵活性和可扩展性使得代码更易于维护和扩展。