策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换-CSDN博客

本文链接：https://blog.csdn.net/blog_programb/article/details/144156909

策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以在不影响客户端的情况下发生变化。

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

Strategy（策略）：这是一个接口或抽象类，定义了所有支持的算法的公共接口。
ConcreteStrategy（具体策略）：实现了Strategy接口或继承自Strategy抽象类的具体类，它实现了具体的算法。
Context（上下文）：使用Strategy接口来调用某ConcreteStrategy定义的算法。Context用一个ConcreteStrategy对象来配置；维护一个对Strategy对象的引用；可定义一个接口来让Strategy访问它的数据。

通过策略模式，我们可以在运行时动态地选择算法，而不需要修改客户端代码。这使得系统更加灵活和可扩展。

策略模式和命令模式都是设计模式中的行为型模式，它们都旨在解决代码的可扩展性和灵活性问题，但它们的关注点和应用场合有所不同。

策略模式（Strategy Pattern）

定义：策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换使用。该模式让算法独立于使用它的客户端而变化。
主要角色：
- Context（上下文）：持有一个Strategy（策略）对象的引用，可以动态地改变所使用的策略。
- Strategy（策略）：定义所有支持的算法的接口。
- ConcreteStrategy（具体策略）：实现Strategy接口的具体类。
应用场景：当需要在运行时根据不同的情况选择不同的算法或行为时，策略模式非常有用。例如，一个支付系统可能需要支持多种支付方式，如信用卡支付、PayPal支付等。
优点：易于添加新算法，符合开闭原则；减少条件判断语句，提高代码的可读性和维护性。

命令模式（Command Pattern）

定义：命令模式将请求封装成对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或者记录日志，以及支持可撤销的操作。
主要角色：
- Command（命令）：声明执行操作的接口。
- ConcreteCommand（具体命令）：实现Command接口，绑定一个Receiver对象，调用接收者相应的操作，以实现Execute方法。
- Invoker（调用者）：要求该命令执行这个请求。
- Receiver（接收者）：知道如何实施与执行一个请求相关的操作。任何类都可能充当Receiver。
应用场景：当你需要将请求封装成对象以便使用不同的请求、队列或者日志请求以及支持可撤销的操作时，命令模式非常有用。例如，文本编辑器中的撤销/重做功能。
优点：解耦了“动作”的发起者和执行者；支持撤销和恢复操作；增加新的命令很容易，因为只需要创建ConcreteCommand类。

总结

策略模式侧重于定义一系列算法，并让这些算法可以相互替换使用，它更关注于算法的选择。
命令模式则侧重于将请求封装为对象，从而可以用不同的请求对客户进行参数化，它更关注于请求的封装和执行过程的控制。

策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法独立于使用它的客户端而变化，从而使得系统更加灵活和可扩展。然而，策略模式并不是在所有情况下都适用，以下是一些策略模式不适用的情况：

算法数量有限且相对稳定：如果系统中的算法数量很少，并且不太可能发生变化，那么使用策略模式可能会引入不必要的复杂性。在这种情况下，直接在代码中实现这些算法可能更为简单和高效。
算法之间差异较小：如果不同策略之间的差异很小，只是某些参数或步骤略有不同，那么使用策略模式可能会导致大量的代码重复，因为每个策略都需要实现几乎相同的逻辑。在这种情况下，可以考虑使用模板方法模式或者直接在一个地方实现这些微小的差异。
上下文对象需要知道策略的具体细节：策略模式的一个核心思想是将算法的实现和使用分离。但如果上下文对象需要知道策略的具体细节才能正确使用它，那么策略模式的优势就大打折扣了。例如，如果上下文对象需要根据策略的类型来执行不同的操作，那么这种依赖关系就破坏了策略模式的初衷。
性能要求极高：虽然策略模式可以提高系统的灵活性和可扩展性，但它也可能引入额外的开销，如对象的创建和销毁、动态绑定等。如果系统对性能的要求非常高，而这些额外开销无法接受，那么可能需要重新考虑是否使用策略模式。
策略的选择非常复杂：在某些情况下，选择合适的策略可能需要复杂的逻辑和大量的条件判断。如果这些逻辑与上下文紧密相关，那么将它们放在策略模式中可能会使代码变得更加复杂和难以维护。在这种情况下，可以考虑将这些逻辑放在上下文中处理。

策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换。策略模式让算法独立于使用它的客户而变化，适用于以下情况：

多个类只是在算法或行为上稍有不同的场景。策略模式使得可以在运行时根据需要选择适当的算法或行为。
需要避免使用多重条件转移语句的场景。策略模式可以将算法的多个分支转移到对应的策略类中，从而避免复杂的条件判断逻辑。
算法可以相互替换的场景。如果一个系统需要多种不同的算法，并且这些算法之间可以互相替换，那么可以使用策略模式为每一个算法实现一个策略类。
希望将算法作为参数传递给对象的场景。在策略模式中，可以将算法封装成策略对象，然后通过构造函数、方法参数等方式传递给需要使用该算法的对象。
希望使用面向对象而不是面向过程编程的场景。策略模式可以帮助你将算法封装到独立的策略类中，从而使你的代码更加符合面向对象的设计原则。
策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式使得算法可以在不影响客户端的情况下发生变化。

实现策略模式通常包括以下几个步骤：

定义策略接口（Strategy）：这是一个抽象类或接口，声明了一组方法，这些方法是所有具体策略需要实现的。
创建具体策略类（ConcreteStrategy）：这些类实现了策略接口中的方法，每个类代表一个具体的算法或行为。
创建上下文类（Context）：这个类维护一个对策略对象的引用，并通过这个引用来调用策略的方法。上下文类通常提供一个方法来设置或改变策略对象。
使用策略模式：在客户端代码中，通过上下文类的接口来使用策略，而不是直接与具体策略类交互。这样可以在运行时动态地改变策略，而不需要修改客户端代码。

例如，假设我们有一个应用程序需要根据不同的支付方式处理订单，我们可以定义一个PaymentStrategy接口，然后为每种支付方式创建一个具体的策略类，如CreditCardPayment、PayPalPayment等。接着，我们创建一个Order类作为上下文，它包含一个PaymentStrategy类型的成员变量，并提供方法来设置和执行支付策略。这样，我们就可以在不修改Order类的情况下添加新的支付方式。

策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。本模式使得算法可以独立于使用它的客户而变化。其优点主要包括：

算法的可替换性：策略模式允许在运行时选择使用哪种算法，增加了程序的灵活性。
避免多重条件选择语句：通过将算法封装在独立的类中，避免了复杂的条件判断，提高了代码的可读性和可维护性。
遵循开闭原则：策略模式允许添加新的算法而无需修改现有的代码，符合面向对象设计的开闭原则。
提高代码复用性：不同的策略实现可以被多个组件共享，提高了代码的复用性。

在Java中实现策略模式通常涉及以下几个步骤：

定义策略接口：首先，你需要定义一个策略接口（Strategy Interface），这个接口声明了所有支持的算法或行为。例如，如果你的策略模式用于处理不同的支付方式，那么策略接口可能包含一个名为 pay 的方法。
实现具体策略类：然后，为每个具体的策略创建一个类，这些类实现了策略接口。每个类都提供了策略接口方法的具体实现。例如，你可能有一个 CreditCardPayment 类和一个 PayPalPayment 类，它们都实现了同一个支付策略接口。
创建上下文类：上下文类（Context Class）用来与客户端交互，它持有一个策略类的引用，并可以动态地改变这个引用。这样，客户端可以通过上下文类来使用不同的策略。
使用策略模式：最后，在客户端代码中，你可以根据需要创建不同的策略对象，并通过上下文类来使用这些策略。这允许你在运行时选择算法或行为，增加了程序的灵活性和可扩展性。

示例代码如下：

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

// 具体策略类 - 信用卡支付
class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

// 具体策略类 - PayPal支付
class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

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

    public int pay(int amount) {
        return paymentStrategy.pay(amount);
    }

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

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

        // 使用信用卡支付
        cart.setPaymentStrategy(new CreditCardPayment());
        int amount = cart.pay(100);
        System.out.println("Paid: " + amount);

        // 切换到PayPal支付
        cart.setPaymentStrategy(new PayPalPayment());
        cart.pay(200);
    }
}