设计模式-策略模式

策略模式（Strategy Pattern） 是一种行为型设计模式，它允许定义一系列算法（或策略），并将每个算法封装起来，使得它们可以互换使用。策略模式让算法的变化独立于使用算法的客户端。

策略模式的关键要点：

1. 上下文（Context）：持有一个策略对象，并且通过调用策略对象的方法来执行特定的算法或操作。
2. 策略接口（Strategy）：定义一系列的算法接口。
3. 具体策略（ConcreteStrategy）：实现策略接口的具体算法。

适用场景：

• 有多种算法或行为时，希望根据不同情况选择不同的算法。
• 你需要对算法进行独立的扩展，不想改变客户端的代码。
• 需要避免在客户端类中使用复杂的条件语句来决定不同的行为。

具体步骤：

1. 定义一个策略接口（Strategy），声明一个算法方法。
2. 创建多个具体策略类（ConcreteStrategy），实现该接口并提供具体的算法实现。
3. 创建一个上下文类（Context），它持有一个策略对象，并委托策略对象执行具体的算法。

代码示例

假设我们有一个计算购物车总价格的需求，购物车可以选择不同的打折策略：满减策略、折扣策略、无折扣策略。

1. 定义策略接口

// 策略接口：定义一个计算价格的方法
public interface PricingStrategy {
    double calculatePrice(double originalPrice);
}

2. 创建具体策略类

// 具体策略1：满减策略
public class DiscountStrategy implements PricingStrategy {
    private double discount;

    public DiscountStrategy(double discount) {
        this.discount = discount;
    }

    @Override
    public double calculatePrice(double originalPrice) {
        return originalPrice - discount;
    }
}

// 具体策略2：折扣策略
public class PercentageDiscountStrategy implements PricingStrategy {
    private double percentage;

    public PercentageDiscountStrategy(double percentage) {
        this.percentage = percentage;
    }

    @Override
    public double calculatePrice(double originalPrice) {
        return originalPrice * (1 - percentage / 100);
    }
}

// 具体策略3：无折扣策略
public class NoDiscountStrategy implements PricingStrategy {
    @Override
    public double calculatePrice(double originalPrice) {
        return originalPrice;
    }
}

3. 创建上下文类

// 上下文类：持有一个策略对象
public class ShoppingCart {
    private PricingStrategy pricingStrategy;

    public ShoppingCart(PricingStrategy pricingStrategy) {
        this.pricingStrategy = pricingStrategy;
    }

    // 设置策略
    public void setPricingStrategy(PricingStrategy pricingStrategy) {
        this.pricingStrategy = pricingStrategy;
    }

    // 计算价格
    public double calculateTotalPrice(double originalPrice) {
        return pricingStrategy.calculatePrice(originalPrice);
    }
}

4. 客户端代码使用策略模式

public class Main {
    public static void main(String[] args) {
        double originalPrice = 200.0;

        // 使用满减策略
        ShoppingCart cart1 = new ShoppingCart(new DiscountStrategy(20.0));
        System.out.println("总价（满减策略）: " + cart1.calculateTotalPrice(originalPrice));

        // 使用折扣策略
        ShoppingCart cart2 = new ShoppingCart(new PercentageDiscountStrategy(10.0));
        System.out.println("总价（折扣策略）: " + cart2.calculateTotalPrice(originalPrice));

        // 使用无折扣策略
        ShoppingCart cart3 = new ShoppingCart(new NoDiscountStrategy());
        System.out.println("总价（无折扣策略）: " + cart3.calculateTotalPrice(originalPrice));
    }
}

输出：

总价（满减策略）: 180.0
总价（折扣策略）: 180.0
总价（无折扣策略）: 200.0

解释：

1. 策略接口 PricingStrategy 定义了一个方法 calculatePrice(double originalPrice)，用于计算价格。
2. 具体策略类：
   • DiscountStrategy 实现了满减策略。
   • PercentageDiscountStrategy 实现了折扣策略。
   • NoDiscountStrategy 实现了无折扣策略。
3. 上下文类 ShoppingCart 持有一个 PricingStrategy 的引用，它在执行 calculateTotalPrice 时委托给具体的策略对象来计算价格。
4. 在客户端代码中，通过传递不同的策略对象（如 DiscountStrategy、PercentageDiscountStrategy 等）来改变计算价格的方式，避免了在 ShoppingCart 类中写大量的条件语句来判断使用哪种策略。

优点：

• 算法的独立性：每个具体策略都封装在独立的类中，策略的改变不会影响其他类的实现。
• 避免了复杂的条件判断：客户端不需要在代码中处理复杂的条件判断，策略的选择和改变变得更加灵活。
• 可扩展性：可以方便地增加新的策略，不需要修改现有代码，只需实现新的策略类。

缺点：

• 类的数量增多：每一种策略都需要一个新的类，可能会导致类的数量增多。
• 客户端需要了解所有的策略类：客户端需要了解所有的策略类型，因此有时可能会导致策略模式的使用不够简洁。

总结：

策略模式通过将不同的算法或行为封装在不同的策略类中，使得算法或行为可以在运行时动态切换，而不需要改变客户端代码的实现。它是一个非常有用的设计模式，尤其在涉及多种变体的算法时，能有效避免复杂的条件判断语句。