实际开发中常用的设计模式--------策略模式(知识跟业务场景结合)-----小白也能看懂(通俗易懂版本)

这篇具有很好参考价值的文章主要介绍了实际开发中常用的设计模式--------策略模式(知识跟业务场景结合)-----小白也能看懂(通俗易懂版本)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.策略模式定义:
策略模式是一种行为型设计模式,它允许在运行时动态地改变对象的行为。策略模式将将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换从而使得算法的变化不会影响到客户端
2.简单的策略模式示例代码:

public interface SortStrategy {
    void sort(int[] data);
}

public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 冒泡排序算法实现
    }
}

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] data) {
        // 快速排序算法实现
    }
}

public class Sorter {
    private SortStrategy strategy;

    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }

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

    public void sort(int[] data) {
        strategy.sort(data);
    }
}

在上述代码中,SortStrategy 表示一个排序策略接口,其中定义了一个 sort() 方法用于对数据进行排序。BubbleSort 和 QuickSort 则表示具体的排序策略类,分别实现了 sort() 方法来进行冒泡排序和快速排序。

而 Sorter 则表示一个排序器类,其中包含一个名为 strategy 的成员变量来存储当前使用的排序策略。通过使用构造函数或者 setter 方法来设置当前使用的排序策略,并且通过调用 sort() 方法来对数据进行排序。

例如,在客户端中可以按照如下方式使用该策略模式:

int[] data = { 5, 2, 4, 6, 1, 3 };
Sorter sorter = new Sorter(new BubbleSort());
sorter.sort(data); // 使用冒泡排序

sorter.setStrategy(new QuickSort());
sorter.sort(data); // 使用快速排序

在上述代码中,我们首先创建了一个数组 data 并且初始化其值。然后创建了一个 Sorter 对象并且使用冒泡排序作为初始的排序策略。最后调用 sort() 方法对数据进行排序,并且通过设置新的排序策略来切换不同的算法。

总之,在策略模式中,我们将不同的算法封装成独立的类,并且使得它们可以互相替换。这样可以使得程序更加灵活和易于维护,并且提高代码复用性和可扩展性。

3.策略模式的基本步骤

策略模式的基本步骤如下:

  1. 定义策略接口:定义一个策略接口,其中包含一个或多个方法用于实现不同的算法。

  2. 实现具体策略类:针对不同的算法,分别实现具体的策略类,并且实现相应的方法。

  3. 定义上下文类:定义一个上下文类,其中包含一个成员变量用于存储当前使用的策略对象,并且提供相应的 setter 方法来设置当前使用的策略对象。

  4. 调用上下文类:在客户端中创建上下文对象,并且通过调用其相应的方法来执行算法。

简单的策略模式示例代码,用于计算两个数的和或差:

1.定义策略接口 OperationStrategy:

public interface OperationStrategy {
    int operate(int num1, int num2);
}

2.实现具体策略类 AdditionStrategy 和 SubtractionStrategy:

public class AdditionStrategy implements OperationStrategy {
    @Override
    public int operate(int num1, int num2) {
        return num1 + num2;
    }
}

public class SubtractionStrategy implements OperationStrategy {
    @Override
    public int operate(int num1, int num2) {
        return num1 - num2;
    }
}

3.定义上下文类 Calculator:

public class Calculator {
    private OperationStrategy strategy;

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

    public int calculate(int num1, int num2) {
        return strategy.operate(num1, num2);
    }
}

4.调用上下文类 Calculator:

// 客户端代码
int a = 10;
int b = 5;

Calculator calculator = new Calculator();
calculator.setStrategy(new AdditionStrategy());
int result = calculator.calculate(a, b); // 计算 a + b

calculator.setStrategy(new SubtractionStrategy());
result = calculator.calculate(a, b); // 计算 a - b

在上述代码中,我们首先定义了一个名为 OperationStrategy 的接口,并且包含一个名为 operate() 的方法用于进行加法或减法操作。然后定义了两个具体的策略类,分别实现了相应的方法来完成加法和减法操作。

接着,我们定义了一个名为 Calculator 的上下文类,并且包含一个成员变量用于存储当前使用的策略对象。通过提供相应的 setter 方法来设置当前使用的策略对象,并且通过调用其 calculate() 方法来执行相应的算法。

最后,在客户端中创建一个 Calculator 对象,并且分别设置不同的策略对象来进行加法或减法操作。

4.实际的业务场景:

假设我们正在开发一个在线商城,需要为用户提供不同的支付方式,例如信用卡、支付宝、微信

首先定义一个支付策略接口 PaymentStrategy,其中包含一个名为 pay() 的方法用于进行支付操作。然后定义具体的支付策略类,例如 CreditCardPayment、AlipayPayment 和 WechatPayment 等,并且分别实现 pay() 方法来完成相应的支付流程。

代码如下:

public interface PaymentStrategy {
    void pay(double amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 信用卡支付流程
    }
}

public class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 支付宝支付流程
    }
}

public class WechatPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 微信支付流程
    }
}

在上述代码中,我们首先定义了一个名为 PaymentStrategy 的接口,并且包含一个名为 pay() 的方法用于进行支付操作。然后定义了三个具体的支付策略类,并且分别实现了 pay() 方法来完成相应的支付流程。

最后,在客户端中根据用户选择的支付方式创建相应的支付策略对象,并且调用其 pay() 方法来进行支付操作。例如:

// 客户端代码
double totalPrice = 1000.0;
String paymentMethod = "credit_card"; // 用户选择信用卡付款

if (paymentMethod.equals("credit_card")) {
    PaymentStrategy paymentStrategy = new CreditCardPayment();
    paymentStrategy.pay(totalPrice);
} else if (paymentMethod.equals("alipay")) {
    PaymentStrategy paymentStrategy = new AlipayPayment();
    paymentStrategy.pay(totalPrice);
} else if (paymentMethod.equals("wechat")) {
    PaymentStrategy paymentStrategy = new WechatPayment();
    paymentStrategy.pay(totalPrice);
}

在上述代码中,我们首先定义了订单总价和用户选择的付款方式(这里假设用户选择信用卡付款)。然后根据用户选择创建相应的支付策略对象,并且调用其 pay() 方法来进行付款操作。文章来源地址https://www.toymoban.com/news/detail-535934.html

到了这里,关于实际开发中常用的设计模式--------策略模式(知识跟业务场景结合)-----小白也能看懂(通俗易懂版本)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

原文地址:https://blog.csdn.net/qq_51711443/article/details/131553366

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包