Java策略模式实例分析

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. 总结

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