Java策略模式

策略模式定义一系列算法，把它们封装起来，并使它们可以互相替换。

模式定义

意图：定义算法族，使它们可以互相替换，让算法变化独立于客户端。

适用场景

• 多种算法可互换
• 需避免条件判断选择算法
• 算法细节需对客户端隐藏

模式结构

策略接口

public interface Strategy {
    int calculate(int a, int b);
}

具体策略

public class AddStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class SubtractStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}

public class MultiplyStrategy implements Strategy {
    @Override
    public int calculate(int a, int b) {
        return a * b;
    }
}

上下文类

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

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

    public int execute(int a, int b) {
        return strategy.calculate(a, b);
    }
}

使用示例

Context context = new Context(new AddStrategy());
System.out.println(context.execute(5, 3));  // 8

context.setStrategy(new MultiplyStrategy());
System.out.println(context.execute(5, 3));  // 15

实际应用示例

支付策略

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

public class CreditCardStrategy implements PaymentStrategy {
    private String cardNumber;

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

    @Override
    public void pay(double amount) {
        System.out.println("信用卡支付: " + amount + "元，卡号: " + cardNumber);
    }
}

public class AlipayStrategy implements PaymentStrategy {
    private String account;

    public AlipayStrategy(String account) {
        this.account = account;
    }

    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount + "元，账号: " + account);
    }
}

public class WechatPayStrategy implements PaymentStrategy {
    private String account;

    public WechatPayStrategy(String account) {
        this.account = account;
    }

    @Override
    public void pay(double amount) {
        System.out.println("微信支付: " + amount + "元，账号: " + account);
    }
}

public class PaymentContext {
    private PaymentStrategy strategy;

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

    public void pay(double amount) {
        strategy.pay(amount);
    }
}

// 使用：动态选择支付方式
PaymentContext context = new PaymentContext(new CreditCardStrategy("12345678"));
context.pay(100);

context = new PaymentContext(new AlipayStrategy("zhang@example.com"));
context.pay(200);

排序策略

public interface SortStrategy {
    void sort(int[] array);
}

public class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // 快速排序实现
        quickSort(array, 0, array.length - 1);
    }

    private void quickSort(int[] arr, int low, int high) { ... }
}

public class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // 冒泡排序实现
    }
}

public class Sorter {
    private SortStrategy strategy;

    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void sort(int[] array) {
        strategy.sort(array);
    }
}

策略工厂

public class StrategyFactory {
    private static Map<String, Strategy> strategies = new HashMap<>();

    static {
        strategies.put("add", new AddStrategy());
        strategies.put("subtract", new SubtractStrategy());
        strategies.put("multiply", new MultiplyStrategy());
    }

    public static Strategy getStrategy(String type) {
        return strategies.get(type);
    }
}

// 使用
Strategy strategy = StrategyFactory.getStrategy("add");
Context context = new Context(strategy);

策略模式优点

1. 算法可自由切换
2. 避免多重条件判断
3. 扩展新策略容易
4. 算法细节对客户端隐藏

策略模式缺点

1. 客户端需知道所有策略
2. 策略类数量增加

策略模式 vs 状态模式

注意事项

策略应独立，无相互依赖

可结合工厂模式创建策略

策略类可共享，减少创建开销

避免策略过多导致客户端选择困难

要点总结

1. 策略模式定义算法族，使算法可互换
2. Strategy接口定义算法方法
3. Context持有策略，委托执行
4. 客户端选择策略，策略之间无转换关系
5. 适用于支付方式、排序算法、折扣计算等场景