在软件开发中，设计模式是解决常见问题的经典方法。策略模式（Strategy Pattern）作为一种行为型设计模式，能够将算法或行为的定义与使用分离，使得算法可以独立于客户端代码进行变化和扩展。本文将深入解析策略模式的核心思想、实现方式以及实际应用场景，并通过代码示例帮助读者掌握其用法。

一、策略模式的核心思想

策略模式的核心思想是：将不同的行为或算法封装为独立的对象，通过上下文动态选择和执行这些策略。这种模式通过解耦业务逻辑与具体算法，使得程序可以在运行时灵活切换算法，而无需修改客户端代码。

1.1 核心角色

策略模式包含以下三个主要角色：

• 抽象策略（Strategy）：定义算法的公共接口，是所有具体策略的抽象。
• 具体策略（Concrete Strategy）：实现抽象策略接口，提供具体的算法实现。
• 上下文（Context）：持有策略对象的引用，负责调用策略，并将算法的选择与执行委托给策略对象。

二、策略模式的结构

策略模式的结构通常如下：

// 抽象策略接口
public interface Strategy {
    void execute();
}

// 具体策略A
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A");
    }
}

// 具体策略B
public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B");
    }
}

// 上下文类
public class Context {
    private Strategy strategy;

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

    public void executeStrategy() {
        if (strategy == null) {
            throw new IllegalStateException("策略未设置");
        }
        strategy.execute();
    }
}

2.1 客户端代码

客户端通过上下文动态选择策略：

public class Client {
    public static void main(String[] args) {
        Context context = new Context();

        // 使用策略A
        context.setStrategy(new ConcreteStrategyA());
        context.executeStrategy(); // 输出: 执行策略A

        // 切换为策略B
        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy(); // 输出: 执行策略B
    }
}

三、策略模式的优点与缺点

3.1 优点

3.2 缺点

1. 客户端需了解所有策略类：客户端需要知道所有可用的策略类，并在运行时选择合适的策略。
2. 类数量增加：策略模式会增加系统中的类数量，可能导致类膨胀，尤其在策略较多时。

四、策略模式的实际应用场景

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

• 需要在不同情况下使用不同的算法：例如支付系统中的多种支付方式（微信支付、支付宝支付、信用卡支付等）。
• 有许多相关类仅在行为上不同：例如电商系统中的折扣策略（会员折扣、季节折扣、满减折扣等）。
• 需要避免复杂的条件语句：例如根据用户类型（普通用户、VIP用户、超级用户）选择不同的权限校验策略。

4.1 示例：支付系统的策略模式

假设我们需要实现一个支付系统，支持多种支付方式（微信支付、支付宝支付、信用卡支付）：

4.1.1 抽象策略接口

public interface PaymentStrategy {
    void pay(double amount);
}

4.1.2 具体策略类

public class WeChatPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付 " + amount + " 元");
    }
}

public class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付 " + amount + " 元");
    }
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用信用卡支付 " + amount + " 元");
    }
}

4.1.3 上下文类

public class PaymentContext {
    private PaymentStrategy paymentStrategy;

    public PaymentContext(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

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

    public void executePayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

4.1.4 客户端代码

public class Client {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext(new WeChatPayment());
        context.executePayment(100.0); // 输出: 使用微信支付 100.0 元

        context.setPaymentStrategy(new AlipayPayment());
        context.executePayment(200.0); // 输出: 使用支付宝支付 200.0 元

        context.setPaymentStrategy(new CreditCardPayment());
        context.executePayment(300.0); // 输出: 使用信用卡支付 300.0 元
    }
}

五、策略模式的变体与优化

5.1 结合工厂模式

为了进一步简化客户端代码，可以将策略的创建与使用分离，结合工厂模式实现策略的动态生成：

接口

public interface PaymentStrategy {
    void pay(double amount);
}    

实现类具体策略类

public class WeChatPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付 " + amount + " 元");
    }
}    

public class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付 " + amount + " 元");
    }
}    

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用信用卡支付 " + amount + " 元");
    }
}    

上下文类

public class PaymentContext {
    private PaymentStrategy paymentStrategy;

    public PaymentContext(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

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

    public void executePayment(double amount) {
        paymentStrategy.pay(amount);
    }
}    

策略工厂

public class PaymentStrategyFactory {
    public static PaymentStrategy createPaymentStrategy(String paymentType) {
        return switch (paymentType.toLowerCase()) {
            case "wechat" -> new WeChatPayment();
            case "alipay" -> new AlipayPayment();
            case "creditcard" -> new CreditCardPayment();
            default -> throw new IllegalArgumentException("不支持的支付类型: " + paymentType);
        };
    }
}    

客户端

public class Client {
    public static void main(String[] args) {
        // 使用工厂创建支付策略
        PaymentStrategy wechatStrategy = PaymentStrategyFactory.createPaymentStrategy("wechat");
        PaymentContext context = new PaymentContext(wechatStrategy);
        context.executePayment(100.0); // 输出: 使用微信支付 100.0 元

        // 动态切换支付策略
        context.setPaymentStrategy(PaymentStrategyFactory.createPaymentStrategy("alipay"));
        context.executePayment(200.0); // 输出: 使用支付宝支付 200.0 元

        // 再次切换
        context.setPaymentStrategy(PaymentStrategyFactory.createPaymentStrategy("creditcard"));
        context.executePayment(300.0); // 输出: 使用信用卡支付 300.0 元
    }
}    

5.2 使用Lambda表达式简化策略模式

在Java 8及以上版本中，可以通过Lambda表达式简化策略的实现，减少类的冗余：

public class LambdaStrategyExample {
    public static void main(String[] args) {
        // 使用Lambda表达式定义策略
        PaymentStrategy customStrategy = (amount) -> {
            System.out.println("使用自定义支付方式支付 " + amount + " 元");
        };

        PaymentContext context = new PaymentContext(customStrategy);
        context.executePayment(500.0); // 输出: 使用自定义支付方式支付 500.0 元
    }
}

六、策略模式与Java内置的策略应用

6.1 Comparator 接口

Java标准库中的Comparator接口是策略模式的经典应用。通过Comparator，我们可以动态定义排序规则：

List<String> list = Arrays.asList("apple", "banana", "cherry");
Collections.sort(list, (a, b) -> a.length() - b.length()); // 按长度排序

七、总结

策略模式是一种灵活且强大的设计模式，能够帮助开发者将算法与业务逻辑解耦，实现动态切换行为。以下是策略模式的关键点总结：

• 适用场景：需要动态切换算法、避免复杂条件语句、扩展性强的场景。
• 优点：算法独立、可替换、符合开闭原则。
• 缺点：类数量增加、客户端需了解所有策略类。

通过合理使用策略模式，可以显著提升代码的灵活性和可维护性。在实际开发中，策略模式常与工厂模式、代理模式等结合使用，以进一步增强系统的扩展性和可配置性。掌握策略模式，将为你的Java开发之路增添一把利器！