Java设计模式之策略模式深入刨析

策略模式是什么？

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

通常情况下，策略模式适用于有多种算法或策略可供选择的场景，程序需要动态选择一种算法或策略的情况下。

什么情况下使用策略模式？

当需要动态选择算法或策略的时候，可以使用策略模式。

比如，在一个在线电商网站中，用户在购物时可以选择不同的支付方式。这些支付方式包括信用卡支付、支付宝支付、微信支付等。在选择支付方式时，我们可以动态选择一种支付策略，以提供更加灵活的支付选择。

策略模式的几个角色

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

1. Context（上下文）: 上下文是客户端代码访问的对象，它提供了一些访问策略的接口。

2. Strategy（策略）: 它定义了一系列的算法或策略，并且抽象了这些算法或策略的公共部分，将具体的算法或策略细节延迟到子类中实现。

3. ConcreteStrategy（具体策略）: 具体策略是策略模式的具体实现，它实现了策略接口中定义的算法或策略，并且负责接收和处理Context传递的数据。

以下是其中一个使用策略模式的示例：

示例一：电商支付系统

在该示例中，我们将实现一个简单的电商支付系统。该系统支持信用卡支付、支付宝支付和微信支付等不同的支付方式。

首先我们需要定义一个支付策略接口：

/**
 * 支付策略接口
 */
public interface PaymentStrategy {
    void pay(double amount);
}

然后，我们需要定义具体的支付策略类，分别对应不同的支付方式：

/**
 * 信用卡支付策略
 */
public class CreditCardPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用信用卡支付 " + amount + " 元");
    }
}

/**
 * 支付宝支付策略
 */
public class AlipayPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付 " + amount + " 元");
    }
}

/**
 * 微信支付策略
 */
public class WechatPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付 " + amount + " 元");
    }
}

最后，我们定义一个上下文类PaymentContext，该类负责接收Request请求，并根据用户选择的不同支付方式来选择相应的具体策略进行支付：

/**
 * 上下文类
 */
public class PaymentContext {
    private PaymentStrategy paymentStrategy;

    /**
     * 根据用户选择的支付方式设置具体策略
     */
    public void setPaymentStrategy(String paymentType) {
        if ("creditCard".equals(paymentType)) {
            paymentStrategy = new CreditCardPaymentStrategy();
        } else if ("alipay".equals(paymentType)) {
            paymentStrategy = new AlipayPaymentStrategy();
        } else if ("wechat".equals(paymentType)) {
            paymentStrategy = new WechatPaymentStrategy();
        }
    }

    /**
     * 调用具体策略进行支付
     */
    public void pay(double amount) {
        paymentStrategy.pay(amount);
    }
}

客户端代码可以使用如下方式来实现支付操作：

public static void main(String[] args) {
    // 创建上下文
    PaymentContext context = new PaymentContext();

    // 设置支付方式为信用卡
    context.setPaymentStrategy("creditCard");

    // 调用支付操作
    context.pay(100);

    // 更换支付方式为支付宝
    context.setPaymentStrategy("alipay");
    context.pay(200);

    // 更换支付方式为微信
    context.setPaymentStrategy("wechat");
    context.pay(300);
}

在上述示例中，我们实现了一个简单的电商支付系统。在该系统实现中，我们使用了策略模式，根据不同的用户选择，选择不同的具体策略进行支付。

示例二：排序算法

在该示例中，我们将展示策略模式在排序算法中的应用。在该示例中，我们实现了不同的排序算法，将其封装成具体的策略，并根据用户选择的不同排序算法，动态选择具体的策略进行排序。

首先我们定义一个排序策略接口：

/**
 * 排序策略接口
 */
public interface SortStrategy {
    void sort(int[] data);
}

然后，我们需要定义具体的排序策略类，分别对应不同的排序算法：

/**
 * 冒泡排序策略
 */
public class BubbleSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        System.out.println("使用冒泡排序算法进行排序");
        // 冒泡排序算法实现
    }
}

/**
 * 快速排序策略
 */
public class QuickSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        System.out.println("使用快速排序算法进行排序");
        // 快速排序算法实现
    }
}

/**
 * 插入排序策略
 */
public class InsertionSortStrategy implements SortStrategy {
    @Override
    public void sort(int[] data) {
        System.out.println("使用插入排序算法进行排序");
        // 插入排序算法实现
    }
}

最后，我们定义一个上下文类SortContext，该类负责接收要排序的数据，并根据选择的排序算法来选择对应的具体策略进行排序，示例代码如下：

/**
 * 上下文类
 */
public class SortContext {
    private SortStrategy sortStrategy;

    /**
     * 根据用户选择的排序算法设置具体策略
     */
    public void setSortStrategy(String sortType) {
        if ("bubble".equals(sortType)) {
            sortStrategy = new BubbleSortStrategy();
        } else if ("quick".equals(sortType)) {
            sortStrategy = new QuickSortStrategy();
        } else if ("insertion".equals(sortType)) {
            sortStrategy = new InsertionSortStrategy();
        }
    }

    /**
     * 调用具体策略进行排序
     */
    public void sort(int[] data) {
        sortStrategy.sort(data);
    }
}

客户端代码可以使用如下方式来实现排序操作：

public static void main(String[] args) {
    // 创建上下文
    SortContext context = new SortContext();

    // 设置排序算法为冒泡排序
    context.setSortStrategy("bubble");

    // 调用排序操作
    int[] data1 = {5, 3, 2, 4, 1};
    context.sort(data1);

    // 更换排序算法为快速排序
    context.setSortStrategy("quick");
    int[] data2 = {5, 3, 2, 4, 1};
    context.sort(data2);

    // 更换排序算法为插入排序
    context.setSortStrategy("insertion");
    int[] data3 = {5, 3, 2, 4, 1};
    context.sort(data3);
}

在上述示例中，我们实现了不同的排序算法，将其封装成具体的策略，并根据用户选择的不同排序算法，动态选择具体的策略进行排序。在该示例中，我们通过策略模式实现了不同排序算法的可插拔性，并且实现了更加灵活的排序算法选择。