Java策略模式实例分析

1. 引言

在软件开发中，设计模式是解决常见问题的经典解决方案。策略模式（Strategy Pattern）是行为型设计模式之一，它允许在运行时选择算法的行为。通过将算法封装在独立的类中，策略模式使得算法可以独立于使用它的客户端而变化。本文将深入探讨策略模式的概念、结构、实现方式，并通过一个具体的Java实例来展示其应用。

2. 策略模式概述

2.1 定义

策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以互换。策略模式使得算法可以独立于使用它的客户端而变化。

2.2 适用场景

• 当一个系统需要在多种算法之间进行切换时。
• 当一个类定义了多种行为，并且这些行为在类的操作中以多个条件语句的形式出现时。
• 当不希望客户端知道复杂的、与算法相关的数据结构时。

2.3 优点

• 开闭原则：可以在不修改原有代码的情况下引入新的策略。
• 消除条件语句：通过使用策略模式，可以避免使用大量的条件语句。
• 提高代码复用性：策略类可以在不同的上下文中复用。

2.4 缺点

• 客户端必须了解所有策略：客户端需要知道所有的策略类，以便选择合适的策略。
• 增加对象数量：每个策略都是一个类，可能会增加系统中对象的数量。

3. 策略模式的结构

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

1. Context（上下文）：持有一个策略类的引用，并提供一个接口来执行策略。
2. Strategy（策略接口）：定义所有支持的算法的公共接口。
3. ConcreteStrategy（具体策略）：实现策略接口的具体算法。

3.1 类图

classDiagram
    class Context {
        -Strategy strategy
        +setStrategy(Strategy strategy)
        +executeStrategy()
    }
    class Strategy {
        <<interface>>
        +execute()
    }
    class ConcreteStrategyA {
        +execute()
    }
    class ConcreteStrategyB {
        +execute()
    }
    class ConcreteStrategyC {
        +execute()
    }
    Context --> Strategy
    Strategy <|.. ConcreteStrategyA
    Strategy <|.. ConcreteStrategyB
    Strategy <|.. ConcreteStrategyC

4. Java实现策略模式

4.1 定义策略接口

首先，我们定义一个策略接口，所有具体的策略类都需要实现这个接口。

public interface Strategy {
    void execute();
}

4.2 实现具体策略类

接下来，我们实现几个具体的策略类，每个类都实现了Strategy接口。

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy B");
    }
}

public class ConcreteStrategyC implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy C");
    }
}

4.3 定义上下文类

上下文类持有一个策略对象的引用，并提供一个方法来执行策略。

public class Context {
    private Strategy strategy;

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

    public void executeStrategy() {
        if (strategy != null) {
            strategy.execute();
        } else {
            System.out.println("No strategy set");
        }
    }
}

4.4 客户端代码

最后，我们编写客户端代码来演示如何使用策略模式。

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context();

        // 使用策略A
        context.setStrategy(new ConcreteStrategyA());
        context.executeStrategy();

        // 使用策略B
        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();

        // 使用策略C
        context.setStrategy(new ConcreteStrategyC());
        context.executeStrategy();
    }
}

4.5 输出结果

运行上述代码，输出结果如下：

Executing Strategy A
Executing Strategy B
Executing Strategy C

5. 策略模式的应用实例

5.1 场景描述

假设我们正在开发一个电商平台，该平台需要根据不同的促销策略来计算商品的最终价格。促销策略包括：无折扣、满减折扣、百分比折扣等。

5.2 实现步骤

5.2.1 定义策略接口

首先，我们定义一个策略接口PromotionStrategy，用于计算商品的最终价格。

public interface PromotionStrategy {
    double applyDiscount(double originalPrice);
}

5.2.2 实现具体策略类

接下来，我们实现几个具体的促销策略类。

public class NoDiscountStrategy implements PromotionStrategy {
    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice;
    }
}

public class FullReductionStrategy implements PromotionStrategy {
    private double fullAmount;
    private double reductionAmount;

    public FullReductionStrategy(double fullAmount, double reductionAmount) {
        this.fullAmount = fullAmount;
        this.reductionAmount = reductionAmount;
    }

    @Override
    public double applyDiscount(double originalPrice) {
        if (originalPrice >= fullAmount) {
            return originalPrice - reductionAmount;
        }
        return originalPrice;
    }
}

public class PercentageDiscountStrategy implements PromotionStrategy {
    private double percentage;

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

    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice * (1 - percentage);
    }
}

5.2.3 定义上下文类

上下文类PricingContext持有一个促销策略对象的引用，并提供一个方法来计算商品的最终价格。

public class PricingContext {
    private PromotionStrategy promotionStrategy;

    public void setPromotionStrategy(PromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    public double calculateFinalPrice(double originalPrice) {
        if (promotionStrategy != null) {
            return promotionStrategy.applyDiscount(originalPrice);
        }
        return originalPrice;
    }
}

5.2.4 客户端代码

最后，我们编写客户端代码来演示如何使用策略模式来计算商品的价格。

public class ECommerceDemo {
    public static void main(String[] args) {
        PricingContext pricingContext = new PricingContext();

        // 无折扣
        pricingContext.setPromotionStrategy(new NoDiscountStrategy());
        System.out.println("Final Price (No Discount): " + pricingContext.calculateFinalPrice(100.0));

        // 满减折扣
        pricingContext.setPromotionStrategy(new FullReductionStrategy(200.0, 50.0));
        System.out.println("Final Price (Full Reduction): " + pricingContext.calculateFinalPrice(250.0));

        // 百分比折扣
        pricingContext.setPromotionStrategy(new PercentageDiscountStrategy(0.2));
        System.out.println("Final Price (Percentage Discount): " + pricingContext.calculateFinalPrice(100.0));
    }
}

5.2.5 输出结果

运行上述代码，输出结果如下：

Final Price (No Discount): 100.0
Final Price (Full Reduction): 200.0
Final Price (Percentage Discount): 80.0

6. 策略模式的扩展与优化

6.1 使用工厂模式简化策略创建

在实际应用中，策略对象的创建可能会比较复杂。我们可以结合工厂模式来简化策略对象的创建过程。

public class PromotionStrategyFactory {
    public static PromotionStrategy getStrategy(String strategyType) {
        switch (strategyType) {
            case "NoDiscount":
                return new NoDiscountStrategy();
            case "FullReduction":
                return new FullReductionStrategy(200.0, 50.0);
            case "PercentageDiscount":
                return new PercentageDiscountStrategy(0.2);
            default:
                throw new IllegalArgumentException("Unknown strategy type: " + strategyType);
        }
    }
}

在客户端代码中，我们可以使用工厂类来获取策略对象。

public class ECommerceDemo {
    public static void main(String[] args) {
        PricingContext pricingContext = new PricingContext();

        // 无折扣
        pricingContext.setPromotionStrategy(PromotionStrategyFactory.getStrategy("NoDiscount"));
        System.out.println("Final Price (No Discount): " + pricingContext.calculateFinalPrice(100.0));

        // 满减折扣
        pricingContext.setPromotionStrategy(PromotionStrategyFactory.getStrategy("FullReduction"));
        System.out.println("Final Price (Full Reduction): " + pricingContext.calculateFinalPrice(250.0));

        // 百分比折扣
        pricingContext.setPromotionStrategy(PromotionStrategyFactory.getStrategy("PercentageDiscount"));
        System.out.println("Final Price (Percentage Discount): " + pricingContext.calculateFinalPrice(100.0));
    }
}

6.2 使用Lambda表达式简化策略实现

在Java 8及以上版本中，我们可以使用Lambda表达式来简化策略模式的实现。由于策略接口只有一个方法，因此可以直接使用Lambda表达式来代替具体的策略类。

public class ECommerceDemo {
    public static void main(String[] args) {
        PricingContext pricingContext = new PricingContext();

        // 无折扣
        pricingContext.setPromotionStrategy(originalPrice -> originalPrice);
        System.out.println("Final Price (No Discount): " + pricingContext.calculateFinalPrice(100.0));

        // 满减折扣
        pricingContext.setPromotionStrategy(originalPrice -> originalPrice >= 200.0 ? originalPrice - 50.0 : originalPrice);
        System.out.println("Final Price (Full Reduction): " + pricingContext.calculateFinalPrice(250.0));

        // 百分比折扣
        pricingContext.setPromotionStrategy(originalPrice -> originalPrice * 0.8);
        System.out.println("Final Price (Percentage Discount): " + pricingContext.calculateFinalPrice(100.0));
    }
}

7. 总结

策略模式是一种非常实用的设计模式，它通过将算法封装在独立的类中，使得算法可以独立于使用它的客户端而变化。本文通过一个电商平台的促销策略实例，详细介绍了策略模式的概念、结构、实现方式以及扩展优化方法。希望本文能够帮助读者更好地理解和应用策略模式。