java设计模式——策略模式

最新推荐文章于 2025-11-14 08:30:00 发布
原创 最新推荐文章于 2025-11-14 08:30:00 发布 · 391 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#策略模式 #java #开发语言

本文通过图书折扣和支付方式选择两个实例，详细介绍了策略模式如何解耦算法，提高代码可维护性和扩展性。通过创建抽象策略接口、具体策略类和环境类，实现场景中不同客户折扣和支付方式的动态切换。

策略模式

介绍

意图：策略模式定义了一系列的算法，并将每一个算法封装起来，使每个算法可以相互替代，使算法本身和使用算法的客户端分割开来，相互独立。

主要解决： 在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用： 一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决： 将这些算法封装成一个一个的类，任意地替换。不是如何来实现算法，而是如何组织和调用这些算法，从而让我们的程序结构更加的灵活、可扩展。

关键代码： 实现同一个接口。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项： 如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题

图书折扣例子

现实生活中我们到商场买东西的时候，卖场往往根据不同的客户制定不同的报价策略，比如针对新客户不打折扣，针对老客户打9折，针对VIP客户打8折… 要针对不同的客户，商家会提供不同的折扣报价。

接下来我们用买图书来举个例子。

我们很有可能写出下面的代码：

public class Test {

    //图书价格
    private static int bookPrice = 100;

    public static void main(String[] args) {
         BigDecimal b = buyBook(BigDecimal.valueOf(bookPrice), "老客户");
         System.out.println(b);
        
    }

    public static BigDecimal buyBook(BigDecimal originalPrice, String customType){
        if ("老客户".equals(customType)) {
            System.out.println("恭喜你！老客户打9折！");
            originalPrice = originalPrice.multiply(new BigDecimal(0.9)).setScale(2,BigDecimal.ROUND_HALF_UP);
            return originalPrice;
        }else if ("VIP客户".equals(customType)) {
            System.out.println("恭喜你！VIP客户打8折！");
            originalPrice = originalPrice.multiply(new BigDecimal(0.8)).setScale(2,BigDecimal.ROUND_HALF_UP);
            return originalPrice;
        }else if("SVIP客户".equals(customType)){
            System.out.println("恭喜你！SVIP客户打7折！");
            originalPrice = originalPrice.multiply(new BigDecimal(0.7)).setScale(2,BigDecimal.ROUND_HALF_UP);
            return originalPrice;
        }
        //其他人员都是原价
        return originalPrice;
    }
}

//控制台输出：
//恭喜你！老客户打9折！
//90.00

上述代码写的很粗糙，把不同客户的报价的算法都放在了同一个方法里面，这样看着代码显得有些臃肿，也会有人说我们把不同用户的优惠都单独放在一个方法里，不就不显得臃肿了吗？

代码如下：

public class Test {

    public BigDecimal buyBook(BigDecimal originalPrice, String customType){
        if ("老客户".equals(customType)) {
            return this.quoteOldCustomer(originalPrice);
        }else if ("VIP客户".equals(customType)) {
            return this.quoteVIPCustomer(originalPrice);
        }else if("SVIP客户".equals(customType)){
            return this.quoteSVIPCustomer(originalPrice);
        }
        //其他人员都是原价
        return originalPrice;
    }

    private BigDecimal quoteSVIPCustomer(BigDecimal originalPrice) {
        System.out.println("恭喜！SVIP打7折");
        originalPrice = originalPrice.multiply(new BigDecimal(0.7)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return originalPrice;
    }

    /**
     * 对VIP客户的报价算法
     * @param originalPrice 原价
     * @return 折后价
     */
    private BigDecimal quoteVIPCustomer(BigDecimal originalPrice) {
        System.out.println("恭喜！VIP客户打8折");
        originalPrice = originalPrice.multiply(new BigDecimal(0.8)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return originalPrice;
    }

    /**
     * 对老客户的报价算法
     * @param originalPrice 原价
     * @return 折后价
     */
    private BigDecimal quoteOldCustomer(BigDecimal originalPrice) {
        System.out.println("恭喜！老客户打9折");
        originalPrice = originalPrice.multiply(new BigDecimal(0.9)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return originalPrice;
    }
}

这个代码比刚开始的时候要好一点，它把每个具体的算法都单独抽出来作为一个方法，当某一个具体的算法有了变动的时候，只需要修改响应的报价算法就可以了。

但是当我们新增一个客户类型的时候，首先要添加一个该种客户类型的报价算法方法，然后再buyBook方法中再加一个else if的分支，是不是感觉很是麻烦呢？而且这也违反了设计原则之一的开闭原则。对于扩展是开放的，对于修改是关闭的。

使用策略模式

这个模式涉及到三个角色：

●　　环境(Context)角色： 持有一个Strategy的引用。

●　　抽象策略(Strategy)角色： 这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

●　　具体策略(ConcreteStrategy)角色： 包装了相关的算法或行为。

在这里插入图片描述

抽象的策略对象

/**
 * 抽象的策略角色
 * @author： zhouzhou
 * @date：2021/10/14 14:23
 */
public interface MemberStrategy {
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    BigDecimal calcPrice(BigDecimal booksPrice);
}

环境对象

/**
 * 环境角色 持有一个Strategy的引用。
 *
 * @author： zhouzhou
 * @date：2021/10/14 14:24
 */
public class PriceContext {
    //持有一个抽象策略的对象
    private MemberStrategy memberStrategy;

    /**
     * 构造函数，传入一个具体策略对象
     * @param memberStrategy    具体策略对象
     */
    public PriceContext(MemberStrategy memberStrategy) {
        this.memberStrategy = memberStrategy;
    }
    /**
     * 计算图书的价格
     * @param booksPrice    图书的原价
     * @return    计算出打折后的价格
     */
    public BigDecimal quote(BigDecimal booksPrice){
        return this.memberStrategy.calcPrice(booksPrice);
    }

}

具体的策略对象

/**
 * 老用户折扣类
 * @author： zhouzhou
 * @date：2021/10/14 14:40
 */
public class OldCustomerStrategy implements MemberStrategy{
    /**
     * 计算图书的价格
     *
     * @param booksPrice 图书的原价
     * @return 计算出打折后的价格
     */
    @Override
    public BigDecimal calcPrice(BigDecimal booksPrice) {
        System.out.println("对于老用户的折扣为：9折");
        booksPrice = booksPrice.multiply(new BigDecimal(0.9)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return booksPrice;
    }
}


/**
 * vip会员折扣类
 *
 * @author： zhouzhou
 * @date：2021/10/14 14:40
 */
public class VipCustomerStrategy implements MemberStrategy{
    /**
     * 计算图书的价格
     *
     * @param booksPrice 图书的原价
     * @return 计算出打折后的价格
     */
    @Override
    public BigDecimal calcPrice(BigDecimal booksPrice) {
        System.out.println("对于VIP用户的折扣为：8折");
        booksPrice = booksPrice.multiply(new BigDecimal(0.8)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return booksPrice;
    }
}


/**
 * SVIP会员折扣类
 *
 * @author： zhouzhou
 * @date：2021/10/14 14:40
 */
public class SVipCustomerStrategy implements MemberStrategy{
    /**
     * 计算图书的价格
     *
     * @param booksPrice 图书的原价
     * @return 计算出打折后的价格
     */
    @Override
    public BigDecimal calcPrice(BigDecimal booksPrice) {
        System.out.println("对于SVIP用户的折扣为：7折");
        booksPrice = booksPrice.multiply(new BigDecimal(0.7)).setScale(2,BigDecimal.ROUND_HALF_UP);
        return booksPrice;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //选择并创建需要使用的策略对象
        MemberStrategy m1 = new VipCustomerStrategy();
        //创建支付环境
        PriceContext priceContext = new PriceContext(m1);
        //获取优惠价格
        BigDecimal quote = priceContext.quote(BigDecimal.valueOf(100));

        System.out.println("图书优惠后的价格为："+ quote);
    }
}

我们忘记了新用户没有优惠怎么办？这个很容易，我们在增加的一个新用户的策略类

/**
 * 新用户折扣类
 * @author： zhouzhou
 * @date：2021/10/14 14:40
 */
public class NewCustomerStrategy implements MemberStrategy{
    /**
     * 计算图书的价格
     *
     * @param booksPrice 图书的原价
     * @return 计算出打折后的价格
     */
    @Override
    public BigDecimal calcPrice(BigDecimal booksPrice) {
        System.out.println("对不起信用户没有折扣，请充值成VIP用户！");
        return booksPrice;
    }
}

/**
 * 测试类
 *
 * @author： zhouzhou
 * @date：2021/10/14 14:43
 */
public class Client {
    public static void main(String[] args) {
        //选择并创建需要使用的策略对象
        MemberStrategy m1 = new VipCustomerStrategy();
        MemberStrategy newUser = new NewCustomerStrategy();
        //创建支付环境
        PriceContext priceContext = new PriceContext(m1);
        PriceContext newUserPrice = new PriceContext(newUser);

        //获取优惠价格
        BigDecimal quote = priceContext.quote(BigDecimal.valueOf(100));

        System.out.println("图书优惠后的价格为："+ quote);
        System.out.println("新用户图书优惠后价格："+newUserPrice.quote(BigDecimal.valueOf(100)));
    }
}

在这里插入图片描述

示例二

模拟下单支付提示选择支付方式，如果用户未选，系统也会默认好推荐的支付方式进行结算。

统一返回值

/**
 * 统一返回值
 *
 * @author： zhouzhou
 * @date：2021/11/8 10:18
 */
@Data
@AllArgsConstructor
public class MsgResult {
    private int code;
    private String msg;
    private Object data;
}

支付方式抽象类

/**
 * 支付渠道
 *
 * @author： zhouzhou
 * @date：2021/11/8 10:20
 */
public abstract class Payment {
    public abstract String getName();

    //通用逻辑被放到抽象类里实现
    public MsgResult pay(String uid, double amount){
        if(queryBalance(uid) < amount){
          return  new MsgResult(500,"支付失败！","余额不足~~");
        }
        return new MsgResult(200,"支付成功！","支付金额" + amount);
    }

    //查询存款
    public abstract double queryBalance(String uid);
}

具体的支付方式

/**
 * 具体的支付方式
 * 支付宝
 * @author： zhouzhou
 * @date：2021/11/8 10:26
 */
public class AliPay extends Payment {
    @Override
    public String getName() {
        return "支付宝";
    }

    @Override
    public double queryBalance(String uid) {
        return 800;
    }
}


/**
 * 具体的支付方式
 * 银行卡
 * @author： zhouzhou
 * @date：2021/11/8 10:26
 */
public class UnionPay extends Payment {
    @Override
    public String getName() {
        return "银行卡";
    }

    @Override
    public double queryBalance(String uid) {
        return 500;
    }
}


/**
 * 具体的支付方式
 * 微信支付
 * @author： zhouzhou
 * @date：2021/11/8 10:26
 */
public class WechatPay extends Payment {
    @Override
    public String getName() {
        return "微信支付";
    }

    @Override
    public double queryBalance(String uid) {
        return 300;
    }
}

支付策略管理

/**
 * 支付策略管理
 * @author： zhouzhou
 * @date：2021/11/8 10:29
 */
public class PayStrategy {

    public static  final String ALI_PAY = "AliPay";
    public static  final String WECHAT_PAY = "WechatPay";
    public static  final String UNION_PAY = "UnionPay";
    public static  final String DEFAULT_PAY = ALI_PAY;

    private static Map<String, Payment> strategy = new HashMap<>();

    static {
        strategy.put(ALI_PAY,new AliPay());
        strategy.put(WECHAT_PAY,new WechatPay());
        strategy.put(UNION_PAY,new UnionPay());
    }

    public static Payment get(String payKey){
        if(!strategy.containsKey(payKey)){
            strategy.get(DEFAULT_PAY);
        }
        return strategy.get(payKey);
    }

}

订单类

@AllArgsConstructor
public class Order {

    private String uid;
    private String orderId;
    private double amount;

    public MsgResult pay(){
        return pay(PayStrategy.DEFAULT_PAY);
    }
    public MsgResult pay(String payKey){
        Payment payment = PayStrategy.get(payKey);
        System.out.println("欢迎使用" + payment.getName());
        System.out.println("本次交易金额为" + amount + "，开始扣款");
        return payment.pay(uid,amount);
    }
}

在这里插入图片描述

Java设计模式——策略模式
流楚丶格念的博客
08-12 1624
注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。（Strategy Pattern）也叫政策模式，是一种比较简单的模式。它的目的是定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。...
设计模式——策略模式
weixin_42564451的博客
08-21 1205
策略模式是一种非常实用的设计模式,它提供了管理算法族、分离算法实现和算法使用的有效方法。通过策略模式,我们可以在不修改原有系统的情况下,灵活地增加新的算法或行为。
Java中的策略设计模式
最佳 Java 编程
06-13 218
策略设计模式是一种行为模式，其中我们有多种算法/策略来完成一项任务，并使用哪种算法/策略留给客户选择。 各种算法选项封装在单独的类中。 在本教程中，我们将学习在Java中实现策略设计模式。 UML表示形式： 首先，我们来看一下策略设计模式的UML表示形式： 在这里，我们有： 策略：定义我们打算执行的常见操作的界面 ConcreteStrategy：这些是使用不同算法来...
Java 策略设计模式
D.K专栏
07-21 605
策略设计模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同的接口的独立类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生。 策略模式的结构 策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象进行管理。策略模式通常把一个系列的算法包装到一些列的策略类里面，作为一个抽象的策略类的子类。 策略模式举例：
设计模式之策略模式：替换复杂混乱的 if else 语句
最新发布
成钰的博客
11-14 391
设计模式之策略模式：替换复杂混乱的 if else 语句。
java 策略设计模式
qq_18430613的博客
06-19 311
转载：https://blog.youkuaiyun.com/qq_38494341/article/details/104018582
java策略设计模式
xckkcxxck的博客
10-19 326
1.概念：举个例子讲解，比如写一个person，有一个show（）方法，她之前是一个丑女，所以去整容了，整容前，-100，整容后，+100， 现在要用编程实现这个例子。 那么普通的想法就是写一个person类，然后整容前，整容后分别写两个子类继承它，并实现不同的show（）方法。 代码如下： public class InterfaceAppDemo1{ public static vo
java设计模式之——策略模式
04-02
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户而变化。这种模式的核心是策略...
精选资源
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
浅析Java设计模式【4】——策略.pdf
07-27
根据给定的信息，本文将对Java设计模式中的“策略”模式进行深入剖析，并结合观察者模式的概念进行讨论。 ### 一、策略模式简介 #### 1.1 概念 策略模式是一种行为型设计模式，它定义了一系列算法，并将每一个算法...
设计模式-策略模式
weixin_33885253的博客
05-09 138
2019独角兽企业重金招聘Python工程师标准>>> ...
java 策略设计模式_java策略设计模式
weixin_32252929的博客
02-12 111
有了接口，那么实现类在哪里呢？还是在ThreadPoolExecutor类中，只是使用了静态内部类的形式：public static class CallerRunsPolicy implementsRejectedExecutionHandler {publicCallerRunsPolicy() { }public voidrejectedExecution(Runnable r, Threa...
JAVA策略设计模式：Strategy
wangking:开源世界，人人都用上了正版啦。。。
12-13 154
  博主 写道 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端   策略模式： 由三部分组成 A:  抽象策略角色：策略类，通...
java 策略设计模式_java设计模式--策略模式
weixin_39820588的博客
02-12 128
策略模式：定义了不同的算法，分别分装起来，让他们可以互相替换，即使算法变化了，也不会影响到使用算法的用户首先定义一个抽象算法类，有两个类继承了这个抽象类，重写了AlgorithmInterface()方法public abstract classStrategy {public abstract voidAlgorithmInterface();}public class AlgorithmA e...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值