Java策略设计模式

简介

策略设计模式是一种行为型设计模式，它允许在运行时选择算法的行为。

在软件开发中，我们常常需要根据不同情况采取不同的行为。通常的做法是使用大量的条件语句来实现这种灵活性，但这会导致代码变得复杂、难以维护和扩展。

策略设计模式通过将每种行为封装到一个独立的类中，并使它们可以相互替换，从而避免了大量的条件判断语句。

示例

假设我们正在开发一个电商平台，需要计算订单的折扣金额。根据不同的用户类型，有不同的折扣策略。

首先，我们定义一个抽象策略类DiscountStrategy，它包含一个抽象方法calculateDiscount用于计算折扣金额。

public abstract class DiscountStrategy {
    public abstract double calculateDiscount(double price);
}

然后，我们创建具体的策略类：RegularCustomerDiscount（普通用户折扣策略）和VIPCustomerDiscount（VIP用户折扣策略）。它们分别继承自DiscountStrategy并实现了calculateDiscount方法。

public class RegularCustomerDiscount extends DiscountStrategy {
    @Override
    public double calculateDiscount(double price) {
        // 普通用户折扣计算逻辑
        return price * 0.9;
    }
}

public class VIPCustomerDiscount extends DiscountStrategy {
    @Override
    public double calculateDiscount(double price) {
        // VIP用户折扣计算逻辑
        return price * 0.8;
    }
}

最后，我们创建一个上下文类Order，它包含一个策略对象，并提供一个方法calculateFinalPrice用于计算订单的最终价格。

public class Order {
    private DiscountStrategy discountStrategy;

    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateFinalPrice(double price) {
        return discountStrategy.calculateDiscount(price);
    }
}

现在，我们可以使用策略模式来计算不同用户类型的订单折扣金额，而无需修改订单类的代码。

public class Main {
    public static void main(String[] args) {
        Order order = new Order();

        // 普通用户订单
        DiscountStrategy regularCustomerDiscount = new RegularCustomerDiscount();
        order.setDiscountStrategy(regularCustomerDiscount);
        double regularCustomerPrice = order.calculateFinalPrice(100);
        System.out.println("普通用户价格：" + regularCustomerPrice);

        // VIP用户订单
        DiscountStrategy vipCustomerDiscount = new VIPCustomerDiscount();
        order.setDiscountStrategy(vipCustomerDiscount);
        double vipCustomerPrice = order.calculateFinalPrice(100);
        System.out.println("VIP用户价格：" + vipCustomerPrice);
    }
}

输出结果：

普通用户价格：90.0
VIP用户价格：80.0

例子二：
让我们以一个商场销售促销活动的场景为例进行代码实现。

假设在商场中有多种促销活动，如打折、满减和赠品活动。根据顾客的购买情况和优惠条件，商场需要动态选择不同的促销策略来给顾客提供最优惠的价格。

首先，我们定义一个抽象的促销策略接口 PromotionStrategy：

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

然后，我们创建具体的促销策略类，分别实现打折、满减和赠品活动的算法：

public class DiscountPromotion implements PromotionStrategy {
    private double discountRate;

    public DiscountPromotion(double discountRate) {
        this.discountRate = discountRate;
    }

    @Override
    public double applyDiscount(double price) {
        return price * (1 - discountRate);
    }
}

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

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

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

public class FreeGiftPromotion implements PromotionStrategy {
    private String gift;

    public FreeGiftPromotion(String gift) {
        this.gift = gift;
    }

    @Override
    public double applyDiscount(double price) {
        System.out.println("You got a free gift: " + gift);
        return price;
    }
}

接下来，我们定义一个商场类 ShoppingMall，其中包含一个促销策略的成员变量，并提供一个设置促销策略的方法：

public class ShoppingMall {
    private PromotionStrategy promotionStrategy;

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

    public double calculatePrice(double price) {
        if (promotionStrategy != null) {
            price = promotionStrategy.applyDiscount(price);
        }
        return price;
    }
}

现在我们可以使用这些类进行测试：

public class Main {
    public static void main(String[] args) {
        ShoppingMall shoppingMall = new ShoppingMall();

        // 设置打折促销策略
        PromotionStrategy discountPromotion = new DiscountPromotion(0.2);
        shoppingMall.setPromotionStrategy(discountPromotion);
        double discountedPrice = shoppingMall.calculatePrice(100);
        System.out.println("Discounted price: " + discountedPrice);

        // 设置满减促销策略
        PromotionStrategy fullReductionPromotion = new FullReductionPromotion(200, 50);
        shoppingMall.setPromotionStrategy(fullReductionPromotion);
        double reducedPrice = shoppingMall.calculatePrice(300);
        System.out.println("Reduced price: " + reducedPrice);

        // 设置赠品促销策略
        PromotionStrategy freeGiftPromotion = new FreeGiftPromotion("T-shirt");
        shoppingMall.setPromotionStrategy(freeGiftPromotion);
        double giftPrice = shoppingMall.calculatePrice(100);
        System.out.println("Final price: " + giftPrice);
    }
}

这段代码首先创建了一个商场对象 shoppingMall，然后通过设置不同的促销策略来计算价格。在不同的促销策略下，商场会根据顾客购买的物品和优惠条件动态选择最优惠的价格。

希望这个例子能够帮助你更好地理解策略模式的实际应用！如果你还有其他问题，请随时提问。
通过使用策略设计模式，我们可以轻松地添加新的折扣策略，而无需修改订单类的代码。这样使得代码更加灵活、可扩展和易于维护。

策略模式的优势

策略设计模式有以下几个优势：

1. 灵活性：策略模式可以根据需要在运行时选择不同的算法，而不需要修改原有的代码。这使得系统更加灵活，可以根据不同的需求动态地切换和替换算法。

2. 可扩展性：由于每个算法都被封装到独立的策略类中，因此很容易添加新的策略。只需要创建一个新的策略类并实现相应的算法即可，而不会影响其他代码的稳定性。

3. 代码复用：策略模式可以将通用的算法逻辑封装到一个抽象策略类中，然后通过继承和实现来扩展具体的策略类。这样可以避免重复编写相同的代码，提高了代码的复用性。

4. 单一责任原则：策略模式能够将不同的算法逻辑分离开来，使得每个策略类只负责自己的算法实现。这符合单一责任原则，使得代码更加清晰、可读性更强。

策略模式的应用场景

策略设计模式在许多场景中都可以发挥作用。以下是一些常见的应用场景：

1. 排序算法：不同的排序算法有不同的实现方式，如冒泡排序、快速排序、插入排序等。使用策略模式可以将这些算法封装到独立的策略类中，并在运行时选择合适的算法。

2. 支付方式：在线购物平台通常支持多种支付方式，如信用卡支付、支付宝、微信支付等。使用策略模式可以将每种支付方式封装到一个独立的策略类中，并根据用户的选择来动态切换支付方式。

3. 日志记录：不同类型的日志可能需要采用不同的记录方式，如文件记录、数据库记录、网络发送等。使用策略模式可以将不同的记录方式封装到策略类中，根据配置或条件来选择合适的记录方式。

4. 缓存策略：在开发中，我们经常会使用缓存来提高系统的性能。不同的数据访问模式可能需要采用不同的缓存策略，如先进先出（FIFO）、最近最少使用（LRU）等。通过使用策略模式，我们可以将不同的缓存策略封装到独立的策略类中，并在运行时选择合适的策略。

5. 图像处理：图像处理涉及许多算法，如调整图像大小、滤镜效果、图像旋转等。使用策略模式可以将不同的图像处理算法封装到独立的策略类中，并根据用户需求选择合适的算法来处理图像。

这些只是策略设计模式的一些常见应用场景，实际上它可以应用于各种需要根据不同条件选择不同行为的情况。通过使用策略模式，我们可以使代码更加灵活、可维护和可扩展，同时降低了代码的复杂度。

希望本文对你理解和应用策略设计模式有所帮助！如果你还有任何问题，请随时提问。

策略模式与其他设计模式的区别

策略模式与其他设计模式有一些相似之处，但也有一些明显的区别。

1. 策略模式 vs. 工厂模式：

   • 工厂模式是一种创建型模式，它将对象的创建逻辑封装到一个工厂类中，客户端通过工厂类来创建对象。而策略模式是一种行为型模式，它将不同的算法封装到独立的策略类中，并在运行时选择合适的策略。
   • 工厂模式主要关注对象的创建，而策略模式主要关注算法的选择和切换。
   • 工厂模式通常用于创建具有相同接口的对象，而策略模式可以用于封装任意类型的算法。

2. 策略模式 vs. 模板方法模式：

   • 模板方法模式是一种行为型模式，它定义了一个算法的骨架，将一些步骤延迟到子类实现。而策略模式则将整个算法封装到独立的策略类中，并在运行时动态选择策略。
   • 模板方法模式强调保持算法骨架的稳定性，而策略模式强调算法的灵活性。

3. 策略模式 vs. 委托模式：

   • 委托模式是一种对象组合模式，它将任务的执行委托给其他对象来完成。而策略模式则是将不同的算法封装到独立的策略类中，并在运行时选择合适的策略。
   • 委托模式侧重于任务的分配和执行，而策略模式侧重于算法的选择和切换。

总的来说，策略模式通过将不同的算法封装到独立的策略类中，使得代码更加灵活、可扩展和可维护。它与工厂模式、模板方法模式和委托模式有一些相似之处，但也有明显的区别。根据具体的需求和场景，我们可以选择适合的设计模式来解决问题。

总结

策略设计模式是一种非常常用且有价值的设计模式，它可以提供灵活、可扩展和可复用的代码结构。通过封装不同的算法到独立的策略类中，策略模式能够简化代码、降低耦合性，并使得系统更加可维护和可扩展。

在实际开发中，我们经常会遇到需要根据不同条件选择不同行为的情况，这时候策略模式就是一个很好的选择。希望本文对你理解和应用策略设计模式有所帮助！

如果你想深入了解策略设计模式，可以参考《Head First 设计模式》一书中关于策略模式的章节，它详细介绍了策略设计模式的原理和实现方式。