Java设计模式十六策略模式 (Strategy Pattern)

最新推荐文章于 2026-01-09 15:15:24 发布

原创最新推荐文章于 2026-01-09 15:15:24 发布 · 656 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #策略模式

设计模式专栏收录该内容

36 篇文章

订阅专栏

策略模式 (Strategy Pattern)

策略模式是一种行为型设计模式，它定义了一系列算法，将每个算法封装成一个独立的类，并使得它们可以互换。策略模式让算法的变化独立于使用算法的客户端。通过使用策略模式，我们可以动态地选择不同的算法，并将它们组合在一起。

1. 策略模式的组成

策略模式通常包含以下几个角色：

Context（上下文）：使用某个具体策略的类。它通常持有一个Strategy类型的引用，并负责通过这个引用来执行具体的算法。
Strategy（策略接口）：定义了所有支持的算法的共同接口，通常是一个抽象类或接口，里面包含一个execute()方法，供具体策略类实现。
ConcreteStrategy（具体策略类）：实现了Strategy接口的具体算法类，每个类封装一个具体的算法。

2. 策略模式的工作流程

客户端通过上下文（Context）对象来选择某种策略。
上下文将策略对象传递给具体的算法类。
策略类执行对应的算法，并返回结果。

3. 策略模式的实现

场景示例：支付系统

假设我们需要实现一个支付系统，支持不同的支付方式（如：支付宝、微信支付、信用卡支付等）。通过策略模式，我们可以为每种支付方式定义一个策略类，并在运行时动态选择支付方式。

1) 定义策略接口

支付的策略接口定义了所有支付方式应具备的行为（如支付方法）。

// 支付策略接口
public interface PaymentStrategy {
    void pay(int amount); // 支付方法
}

2) 定义具体策略类

每个支付方式都实现了PaymentStrategy接口，封装了具体的支付算法。

// 支付宝支付
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Using Alipay to pay: " + amount + " yuan.");
    }
}

// 微信支付
public class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Using WeChat Pay to pay: " + amount + " yuan.");
    }
}

// 信用卡支付
public class CreditCardPayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Using Credit Card to pay: " + amount + " yuan.");
    }
}

3) 定义上下文类

上下文类（PaymentContext）负责根据用户选择的支付方式来委托具体的策略类执行支付。

// 上下文类
public class PaymentContext {
    private PaymentStrategy paymentStrategy;

    // 设置支付策略
    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    // 执行支付
    public void executePayment(int amount) {
        paymentStrategy.pay(amount);
    }
}

4) 客户端代码

客户端代码通过上下文类来选择不同的支付方式，并执行支付操作。

public class Client {
    public static void main(String[] args) {
        // 创建上下文类
        PaymentContext paymentContext = new PaymentContext();
        
        // 选择支付宝支付
        paymentContext.setPaymentStrategy(new AlipayStrategy());
        paymentContext.executePayment(100);  // 输出：Using Alipay to pay: 100 yuan.
        
        // 选择微信支付
        paymentContext.setPaymentStrategy(new WeChatPayStrategy());
        paymentContext.executePayment(200);  // 输出：Using WeChat Pay to pay: 200 yuan.
        
        // 选择信用卡支付
        paymentContext.setPaymentStrategy(new CreditCardPayStrategy());
        paymentContext.executePayment(300);  // 输出：Using Credit Card to pay: 300 yuan.
    }
}

运行结果：

Using Alipay to pay: 100 yuan.
Using WeChat Pay to pay: 200 yuan.
Using Credit Card to pay: 300 yuan.

4. 策略模式的优点

符合开闭原则： 增加新的支付方式只需要添加一个新的ConcreteStrategy类，而不需要修改现有的代码。
避免了大量的条件判断： 不需要使用if-else或switch-case来判断哪种支付方式，避免了复杂的条件语句。
易于扩展： 可以轻松添加新的策略，每种策略的实现都相对独立，不会影响其他部分。
可以动态切换策略： 客户端可以在运行时改变策略类，灵活控制不同的算法。

5. 策略模式的缺点

客户端必须了解所有策略： 上下文类需要知道所有可能的策略并选择一个。若策略过多，客户端的选择逻辑可能会变得复杂。
类的数量增加： 每一种策略都会增加一个新的类，这可能导致类的数量过多，增加系统复杂度。

6. 策略模式的应用场景

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

算法或行为的多种变体： 当同一个任务需要多个算法来处理时（例如，支付系统、排序算法等）。
客户端需要动态选择算法时： 如果算法在运行时可能会发生变化，策略模式就非常适用。
避免使用大量的if-else或switch-case： 通过策略模式将条件判断移到不同的策略类中，从而使代码更加简洁易懂。

7. 总结

策略模式通过将算法封装在独立的策略类中，使得算法的切换变得更加灵活。它避免了在代码中出现大量的条件判断，使得系统更加符合开闭原则，便于扩展和维护。尤其在面对需要多种行为或算法的场景下，策略模式提供了一种非常有效的解决方案。