Java设计模式：策略模式

? 作者主页：欢迎来到我的技术博客😎
? 个人介绍：大家好，本人热衷于Java后端开发，欢迎来交流学习哦！(￣▽￣)~*
🍊 如果文章对您有帮助，记得关注、点赞、收藏、评论??????
📣 您的支持将是我创作的动力，让我们一起加油进步吧！！！🎉🎉

一、策略模式的定义

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

---

二、策略模式的结构

策略模式包含以下重要角色：

• 抽象策略类（Strategy） ： 这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
• 具体策略类（Concrete Strategy） ： 实现了抽象策略定义的接口，提供具体的算法实现或行为。
• 环境类（Context） ： 持有一个策略类的引用，最终给客户端调用。

---

三、策略模式的实现

需求案例：假设我们正在开发一个支付系统，可以根据用户的选择使用不同的支付方式进行支付，比如现金、信用卡或支付宝。

要实现该需求，我们使用传统的方式也是可以实现的，具体的代码实现如下：

支付服务类：

public class PaymentService {

  public void processPayment(String paymentMethod, int amount) {

      if ("cash".equals(paymentMethod)) {
        System.out.println("使用现金支付了" + amount);
      } else if ("creditCard".equals(paymentMethod)) {
        // 这里可能涉及到creditCard的一些验证逻辑，这里简化为输出
        System.out.println("使用信用卡支付了" + amount);
      } else if ("alipay".equals(paymentMethod)) {
        // 这里可能涉及到Alipay账户的一些验证逻辑，这里简化为输出
        System.out.println("使用支付宝支付了" + amount);
      } else {
        System.out.println("不支持该付款方式");
      }
  }
  
}

客户端类：

public class PaymentSystemWithoutStrategy {
  public static void main(String[] args) {

    PaymentService paymentService = new PaymentService();

    // 使用不同的支付方式进行支付
    paymentService.processPayment("cash", 100);
    paymentService.processPayment("creditCard", 200);
    paymentService.processPayment("alipay", 300);
    paymentService.processPayment("invalidMethod", 50);
  }
  
}

测试结果：

?

通过传统的方式，我们可以发现主要使用的是大量的 if-else 语句去进行判断从而选择不同的算法，如果需要添加新的条件或算法的时候则需要在原有的 if-else 结构中去插入新的条件分支，这就违反 开闭原则 ，并且大量的嵌套条件语句使得代码难以理解，降低了代码的可读性，增加了理解和维护的难度。

---

因此，我们使用 策略模式 就能完美解决上面出现的问题。

接下来，我们使用策略模式对案例进行改造，类图如下：

?

具体的类设计入如下：

抽象策略类：

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

具体策略类（现金支付类）：

public class CashPayment implements PaymentStrategy {
  
  @Override
  public void pay(int amount) {
    System.out.println("使用现金支付了" + amount);
  }
  
}

具体策略类（支付宝支付类）：

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

具体策略类（信用卡支付类）：

public class CreditCardPayment implements PaymentStrategy {
  
    @Override
    public void pay(int 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 payAmount(int amount) {
      paymentStrategy.pay(amount);
    }
  
}

客户端类：

public class PaymentSystem {
  
    public static void main(String[] args) {
      // 创建不同的支付策略
      PaymentStrategy cashPayment = new CashPayment();
      PaymentStrategy creditCardPayment = new CreditCardPayment();
      PaymentStrategy alipayPayment = new AlipayPayment();
  
      // 使用不同的支付方式进行支付
      PaymentContext paymentContext = new PaymentContext(cashPayment);
      paymentContext.payAmount(100);
  
      paymentContext.setPaymentStrategy(creditCardPayment);
      paymentContext.payAmount(200);
  
      paymentContext.setPaymentStrategy(alipayPayment);
      paymentContext.payAmount(300);
    }
  
}

测试结果：

---

四、策略模式的优缺点

优点：

• 策略类之间可以自由切换，由于策略类都实现同一个接口，所以使得他们之间可以自由切换；
• 易于扩展，增加一个新的策略只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合“开闭原则”
• 避免使用多重条件语句（if-else），充分体现面向对象设计思想；

缺点：

• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类；
• 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量；

---

五、策略模式的使用场景

策略模式主要有以下几种使用场景：

• 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
• 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
• 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
• 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
• 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

---

六、扩展：策略模式和工厂模式的结合

在策略模式中，我们可以发现就是对象的实例化还是由客户端去完成，因此我们可以引入 工厂模式 来解耦客户端代码和具体策略类的实现，将对象的实例化逻辑封装到工厂类中，使客户无需了解和处理具体对象的创建过程，客户 只需专注于选择合适的策略而不是对象的创建。

因此，我们引入工厂模式对上述案例进行改造，具体的类实现如下：
对于抽象策略类和具体策略类不需要修改，我们只需要对客户端类进行修改并且新增策略工厂类即可。

策略工厂类：

public class PaymentStrategyFactory {

    private Map<String, PaymentStrategy> strategyMap;

    public PaymentStrategyFactory() {

        strategyMap = new HashMap<>();
        strategyMap.put("cash", new CashPayment());
        strategyMap.put("creditCard", new CreditCardPayment());
        strategyMap.put("alipay", new AlipayPayment());
        // 可以在这里添加更多的策略类
    }

    public PaymentStrategy createPaymentStrategy(String paymentType) {

        return strategyMap.get(paymentType);
    }

}

客户端类：

public class PaymentExample {

    public static void main(String[] args) {
        PaymentStrategyFactory factory = new PaymentStrategyFactory();

        //通过策略工厂类创建对象
        PaymentStrategy cashPayment = factory.createPaymentStrategy("cash");
        PaymentStrategy creditCardPayment = factory.createPaymentStrategy("creditCard");
        PaymentStrategy alipayPayment = factory.createPaymentStrategy("alipay");

        //执行支付功能
        cashPayment.pay(100);
        creditCardPayment.pay(200);
        alipayPayment.pay(300);
    }

}

---

七、扩展：策略模式和工厂模式的区别

策略模式和工厂模式在某些方面的实现上可能会相似，容易在初学时混淆。这是因为它们都涉及到对象的创建和封装，而且都有助于降低系统的耦合度。然而，它们的关注点和应用场景是不同的。

为了更清晰地区分它们，可以从以下几点进行区分：

1. 关注点不同 ：

   • 策略模式： 关注的是定义一系列算法，并将每个算法封装起来，使它们可以相互替换，客户端可以独立于算法的变化而变化。
   • 工厂模式 ： 关注的是对象的创建过程，通过工厂来封装对象的创建，使客户端不需要直接负责对象的实例化。

2. 用途不同 ：

   • 策略模式 ： 适用于需要在运行时动态选择算法或策略的场景。
   • 工厂模式 ： 适用于需要创建一组相关或相似对象的场景。

3. 角色不同 ：

   • 策略模式 ：主要包括策略接口和具体策略类，客户端负责选择并使用具体的策略。
   • 工厂模式 ： 主要包括工厂接口和具体工厂类，客户端通过工厂获取对象，而不直接实例化对象。

4. 变化原因不同 ：

   • 策略模式 ：变化原因是算法或策略的变化，通过封装不同的算法实现来应对变化。
   • 工厂模式 ： 变化原因是对象的创建方式的变化，通过封装对象的创建过程来应对变化。

总的来说，策略模式主要关注算法的封装和动态切换，而工厂模式主要关注对象的创建过程的封装和解耦。在实际应用中，这两种模式可以结合使用，例如在策略模式中使用工厂来创建具体的策略对象。

---

?
非常感谢您阅读到这里，如果这篇文章对您有帮助，希望能留下您的点赞👍 关注💖 分享👥 留言💬thanks！！！