Java的策略模式

最新推荐文章于 2024-03-01 09:59:47 发布
最新推荐文章于 2024-03-01 09:59:47 发布
阅读量175 收藏
点赞数
文章标签： 策略模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21551773/article/details/126514167
版权
这篇博客通过一个餐厅打折优惠的例子介绍了如何使用Java实现策略模式。博主首先展示了传统做法，然后重构代码，实现了策略接口和具体策略类，利用枚举来存储折扣信息，并通过策略上下文选择合适的打折策略。最终，通过策略模式使得代码更加灵活和易于扩展。
摘要由CSDN通过智能技术生成

Java的策略模式

今天难得母亲大人休息，跟外婆妹妹她们一起去喝早茶，本来是很平常的一餐，但当结账时我看到了餐厅上写的打折优惠（具体部分没有拍照，大致是下面这样子），心里若有所思，觉得跟 Java 的策略模式很相像。刚好我也没有具体去实现过策略模式，趁着这个机会，自己试着实现了一下策略模式。

08:30 - 11:30 打 6.8 折	以结算时间为准
12:00 - 17:00 打 8.8 折	以入单时间为准
19:30 - 22:00 打 7.0 折	以入单时间为准

需求（自己添加的）
根据入单时间和结算时间，计算本次的消费金额

当我写完后，去网上看了一下具体的策略模式，发现网上的好像比我写的要简单一点，网上的是根据具体的策略手动 new 出来一个策略对象的🤣。下面贴一下我的代码，如果这不是策略模式的话，请轻喷！还请各位不吝赐教！！！

先贴一个最朴素的做法

public class StrategyMain {
    static Calendar startTime = Calendar.getInstance();
    static Calendar endTime = Calendar.getInstance();

    public static void main(String[] args) {

        startTime.set(2022, Calendar.OCTOBER, 24, 9, 0);
        endTime.set(2022, Calendar.OCTOBER, 24, 10, 32);

        Order order = new Order(126, new Date(startTime.getTimeInMillis()), new Date(endTime.getTimeInMillis()));

        if (inGo(order.getEndTime().getTime())) {
            System.out.println("消费金额为 " + order.getPay() * 0.68 + " 元，打 6.8 折");
        } else if (inAm(order.getStartTime().getTime())) {
            System.out.println("消费金额为 " + order.getPay() * 0.88 + " 元， 打 8.8 折");
        } else if (inPm(order.getStartTime().getTime())) {
            System.out.println("消费金额为 " + order.getPay() * 0.70 + " 元， 打 7.0 折");
        } else {
            System.out.println("消费金额为 " + order.getPay() + " 元，没有打折");
        }


    }

    // 08:30 - 11:30 打 6.8 折	以结算时间为准
    private static boolean inGo(long t) {
        startTime.set(2022, Calendar.OCTOBER, 24, 8, 30);
        endTime.set(2022, Calendar.OCTOBER, 24, 11, 30);

        return startTime.getTimeInMillis() <= t && t <= endTime.getTimeInMillis();
    }

    // 12:00 - 17:00 打 8.8 折	以入单时间为准
    private static boolean inAm(long t) {
        startTime.set(2022, Calendar.OCTOBER, 24, 12, 0);
        endTime.set(2022, Calendar.OCTOBER, 24, 17, 0);

        return startTime.getTimeInMillis() <= t && t <= endTime.getTimeInMillis();
    }

    // 19:30 - 22:00 打 7.0 折	以入单时间为准
    private static boolean inPm(long t) {
        startTime.set(2022, Calendar.OCTOBER, 24, 19, 30);
        endTime.set(2022, Calendar.OCTOBER, 24, 22, 0);

        return startTime.getTimeInMillis() <= t && t <= endTime.getTimeInMillis();
    }

输出结果

消费金额为 85.68 元，打 6.8 折

下面是使用了策略模式的做法

先定义订单实体类 Order （简化）

package com.zmz.entity;

import java.util.Date;

public class Order {

    private double pay; // 支付金额
    private Date startTime; // 开始时间
    private Date endTime; // 结束时间

    public Order() {
    }

    public Order(double pay, Date startTime, Date endTime) {
        this.pay = pay;
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public double getPay() {
        return pay;
    }

    public void setPay(double pay) {
        this.pay = pay;
    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }

    @Override
    public String toString() {
        return "Order{" +
                "pay=" + pay +
                ", startTime=" + startTime +
                ", endTime=" + endTime +
                '}';
    }
}

策略接口

package com.zmz.strategy;

import com.zmz.entity.Order;

import java.util.Calendar;

public interface OrderStrategy {

    /**
     * 根据传入的开始时间和结束时间，选择具体的策略
     */
    default void strategy(Order order) {
        System.out.println("消费金额为 " + order.getPay() + " 元，没有打折");
    }

}

具体策略

// 08:30 - 11:30 打 6.8 折	以结算时间为准
package com.zmz.strategy.impl;

import com.zmz.entity.Order;
import com.zmz.strategy.StrategyEnum;
import com.zmz.strategy.OrderStrategy;

public class OrderStrategyGo implements OrderStrategy {

    @Override
    public void strategy(Order order) {
        System.out.println("消费金额为 " + order.getPay() * StrategyEnum.GO.getDiscount() + " 元，打 6.8 折");
    }

}


// 12:00 - 17:00 打 8.8 折	以入单时间为准
package com.zmz.strategy.impl;

import com.zmz.entity.Order;
import com.zmz.strategy.StrategyEnum;
import com.zmz.strategy.OrderStrategy;

public class OrderStrategyAm implements OrderStrategy {

    @Override
    public void strategy(Order order) {
        System.out.println("消费金额为 " + order.getPay() * StrategyEnum.AM.getDiscount() + " 元， 打 8.8 折");
    }

}


// 19:30 - 22:00 打 7.0 折	以入单时间为准
package com.zmz.strategy.impl;

import com.zmz.entity.Order;
import com.zmz.strategy.StrategyEnum;
import com.zmz.strategy.OrderStrategy;

public class OrderStrategyPm implements OrderStrategy {

    @Override
    public void strategy(Order order) {
        System.out.println("消费金额为 " + order.getPay() * StrategyEnum.PM.getDiscount() + " 元， 打 7.0 折");
    }

}

为了方便，写了一个枚举类

package com.zmz.strategy;

import com.zmz.strategy.impl.OrderStrategyAm;
import com.zmz.strategy.impl.OrderStrategyGo;
import com.zmz.strategy.impl.OrderStrategyPm;

public enum StrategyEnum {
    GO, // 08:30 - 11:30 打 6.8 折	以结算时间为准
    AM, // 12:00 - 17:00 打 8.8 折	以入单时间为准
    PM, // 19:30 - 22:00 打 7.0 折	以入单时间为准
    DEFAULT;

    private int low; // 满足该策略的时间最小分数
    private int height; // 满足该策略的时间最大分数
    private double discount; // 具体折扣
    private OrderStrategy orderStrategy; // 持有的策略

    static {
        init(StrategyEnum::GOInit);
        init(StrategyEnum::AMInit);
        init(StrategyEnum::PMInit);
        init(StrategyEnum::defaultInit);
    }

    StrategyEnum() {
    }

    private static void init(Runnable runnable) {
        runnable.run();
    }

    private static void GOInit() {
        GO.low = 8 * 60 + 30;
        GO.height = 11 * 60 + 30;
        GO.discount = 0.68;
        GO.orderStrategy = new OrderStrategyGo();
    }

    private static void AMInit() {
        AM.low = 12 * 60 + 0;
        AM.height = 17 * 60 + 0;
        AM.orderStrategy = new OrderStrategyAm();
        AM.discount = 0.88;
    }

    private static void PMInit() {
        PM.low = 19 * 60 + 30;
        PM.height = 22 * 60 + 0;
        PM.discount = 0.70;
        PM.orderStrategy = new OrderStrategyPm();
    }

    private static void defaultInit() {
        DEFAULT.discount = 1.0;
        DEFAULT.orderStrategy = new OrderStrategy() {
        };
    }

    public int getLow() {
        return low;
    }

    public int getHeight() {
        return height;
    }

    public double getDiscount() {
        return discount;
    }

    public OrderStrategy getStrategyService() {
        return orderStrategy;
    }
}

补充

枚举类的 low 和 height 属性说明

各个策略的选择只与订单的入单时间或结单时间的小时和分钟有关系，所以可以将具体的时间转换为一个唯一的值，简化选择策略的步骤。具体算法： 小时数 * 60 + 分钟数

策略上下文

package com.zmz.strategy;

import java.util.Date;

public class StrategyContext {


    public static OrderStrategy chooseStrategy(long start, long end) {
        switch (chooseEnum(start, end)) {
            case GO:
                return StrategyEnum.GO.getStrategyService();
            case AM:
                return StrategyEnum.AM.getStrategyService();
            case PM:
                return StrategyEnum.PM.getStrategyService();
            default:
                return StrategyEnum.DEFAULT.getStrategyService();

        }
    }

    private static StrategyEnum chooseEnum(long start, long end) {
        int low = new Date(start).getHours() * 60 + new Date(start).getMinutes();
        int height = new Date(end).getHours() * 60 + new Date(end).getMinutes();

        if (StrategyEnum.GO.getLow() < height && height <= StrategyEnum.GO.getHeight()) {
            return StrategyEnum.GO;
        } else if (StrategyEnum.AM.getLow() <= low && low < StrategyEnum.AM.getHeight()) {
            return StrategyEnum.AM;
        } else if (StrategyEnum.PM.getLow() <= low && low < StrategyEnum.PM.getHeight()) {
            return StrategyEnum.PM;
        }

        return StrategyEnum.DEFAULT;
    }


}

测试

package com.zmz;

import com.zmz.entity.Order;
import com.zmz.strategy.OrderStrategy;
import com.zmz.strategy.StrategyContext;

import java.util.Calendar;
import java.util.Date;

public class StrategyMain {
    static Calendar startTime = Calendar.getInstance();
    static Calendar endTime = Calendar.getInstance();

    public static void main(String[] args) {

        startTime.set(2022, Calendar.OCTOBER, 24, 9, 0);
        endTime.set(2022, Calendar.OCTOBER, 24, 10, 32);
        Order order = new Order(126, new Date(startTime.getTimeInMillis()), new Date(endTime.getTimeInMillis()));

        OrderStrategy orderStrategy = StrategyContext.chooseStrategy(order.getStartTime().getTime(), order.getEndTime().getTime());
        orderStrategy.strategy(order);


    }
}

输出

消费金额为 85.68 元，打 6.8 折

最后

只要知道订单的入单时间和结单时间，就能自动选择策略来确定具体的折扣！

大家都有一个铭治
关注
策略模式实现多种支付方式
dsy__的博客
01-10 478
*策略上下文角色** PayStrategyFactory：策略上下文，负责和具体的策略实现交互，通常策略上下文对象会持有一个真正的策略实现对象，策略上下文还可以让具体的策略实现从其中获取相关数据，回调策略上下文对象的方法。System.out.println("用户选择 支付宝 支付，订单号为：" + orderId + " ，支付金额：" + amount);System.out.println("用户选择 京东 支付，订单号为：" + orderId + " ，支付金额：" + amount);
JAVA设计模式之策略模式---支付
2201_75287416的博客
09-27 251
中的标识符来获取相应的 Spring Bean 实例，使得你可以动态选择并获取不同的服务组件实例，而不需要显式地创建对象。注：这里的支付并不是支付方式（微信，支付宝）而是根据业务来的不同支付节点，比如定金（预付款）运费，尾款根据不同的支付节点处理不同的业务逻辑。=====================那么策略模式的大体结构就是这样======================下面这个接口就相当于类图中Strategy（策略类），支持所有的公共接口。在本文末尾会比较策略模式与工厂模式和装饰者模式的区别。
java网络代理小策略
珍惜
01-10 172
最近在实验室中，做一个网络爬搜索，但是电脑用了代理，URLConnection con=url.OpenConnection()连接不到代理上。看了看网络资料，最后问题解决。 java使用网络代理的两种机制: （1）java中系统环境中的属性设置、 Properties pro=System.getProperties(); pro.setPropert("http.proxyHost",...
策略模式-java实现
最新发布
qq_45653382的博客
03-01 955
以支付为例，用户在支付商品时，可以有多种支付方式，如支付宝，微信，现金。当支付方式增多，支付策略复杂化，我们就要考虑使用策略模式，这样可以避免if else 成堆出现，既不美观也很容易出错。通过枚举的ordinal 我们知道AlPay是0，WxPay是1，CashPay是2，我们就建立了一对一关系，只要给我数字这里就可以通过getPayTypeEnum()返回对应的枚举。通过Map的get方法提供Bean的名字，获取对应的支付现实类。实现支付接口(不同的支付方式有不同的策略)接收支付类型和支付金额。
用一个支付案例带你理解策略模式（模拟不同的支付）
lp18871701190的博客
08-21 1306
首先创建一个支付渠道的抽象类 package paymethod; /** * 支付通道 * @author lp */ public abstract class PayAccess { //支付类型的抽象方法 public abstract String getName(); //查询余额的抽象方法 protected abstract doub...
java策略模式示例.zip
09-26
Java策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常涉及到定义一系列算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户。这个"java策略模式示例....
java策略模式
06-19
应用：通过一个简单的例子，描述学生给玩游戏和看电影的学生把风，如果看见老师来了，则通知玩游戏和看电影的学生老师来了，该学习了，老师没看见玩游戏和看电影的学生做小动作。如果没看见老师，则玩游戏和看电影的...
Java策略模式的简单应用实现方法
09-04
Java策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在上述代码中，策略模式被用来处理不同图片格式的保存策略。这个简单的应用实现了动态选择并执行不同的保存策略，具体步骤如下： 1. **定义策略...
java 策略模式的源码
12-14
通过下载的"DesignPattern"压缩包，你可以查看和学习Java策略模式的具体实现。这个源码可能包含了多个策略类、策略接口和使用策略模式的上下文类，以及示例代码来演示如何在运行时切换策略。通过阅读和理解这些代码...
java策略模式案例_java策略模式典型案例
weixin_32452127的博客
02-27 913
java策略模式典型案例java策略模式典型案例[var1]参考代码 :https://github.com/zhang-xiaoxiang/DesignPatterns23没有用策略模式我们一般是下面的写法,直接写一个类,在类里面直接写策略算法(功能实现)//package com.demo.strategy;/*** NoStrategy:没有策略的做法* 实现起来比较容易，符合一般开发人员...
Java设计模式 | 基于订单批量支付场景，对策略模式和简单工厂模式进行简单实现
程序员雅痞的博客
10-19 1362
使用策略模式+简单工厂模式 模拟批量支付场景。
Java 策略模式（strategy）
清泉影月
06-19 262
前言： 问：啥是“策略” 答：不同情况不同处理呗 问：那不就是 if…else 或者 switch 吗 答：本质上差不多吧 问：总有区别的吧，“策略”听起来感觉高级些 答：那肯定啊 问：到底啥区别 答：高级的东西用起来舒服，价格也贵 问：…，可以不用吗 答：可以啊，又没人逼你 问：那么豪横吗，来一套试试 1.策略模式举例 “策略”就如前言所说，这里举一个常见的栗子，我们去超市买东西，结账的时候会被各种询问， 收银妹子：您是会员吗 鄙人：不是 收银妹子：会员九五折，只需要登记一下手机号就行了呢，要不要开通一下
Java设计模式-策略模式分析
u011058616的博客
10-05 2628
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 策略模式博文简介策略模式的定义及应用场景策略模式实现选择支付方式的业务场景二、使用步骤1.引入库2.读入数据总结 博文简介 通过对策略模式的学习，消除程序中大量的冗余代码和多重条件转移语句。 策略模式的定义及应用场景 策略模式的定义 策略模式（Strategy Pattern）是指定义了算法家族、分别封装起来，让它们之间可以互 相替换，此模式让算法的变化不会影响到使用算法的用户。 策略模式的应用场景 1、假如系统中有很多类，而他们的区别
Java常用设计模式-策略模式
SharingOfficer的博客
12-18 601
策略模式是一个非常实用的设计模式，指定义了一类算法并将其封装起来，并使得它们之间可以灵活地切换，并且不影响客户端。 1，从一个例子开始 我们常常会在网上买东西，很多购物平台都会有着各种各样的优惠策略供你选择例如满减优惠、返现优惠等等。 假设现在要开发一个商城系统，并要开发优惠策略，需要实现不使用优惠、满减优惠和返现优惠三个策略。 这一步很简单，我们将优惠进行抽象，创建一个优惠接口Promotion如下： package fun.swsk33site.strategy.promotion; im
Java设计模式-策略模式(Strategy）
qq_37400096的博客
09-29 806
策略设计模式体现了几个设计原则，第一、把变化的代码从不中分离出来；第二、面对接口编程；三多用组合/聚合， 少用继承。
Java使用策略模式实现多种支付此文案例使用策略实现阿里云腾讯云存储等多种存储
风水道人
12-11 1173
策略模式的关键思想是封装可替换的算法，并提供一种在运行时动态切换它们的方式。这使得代码更加灵活和可扩展。1. 上下文(Context)：这是包含算法的类，并提供一种设置所需策略的方式。Java策略模式是一种行为型设计模式，它定义了一系列的算法，将每个算法封装起来，使它们可以相互替换，并且可以独立于客户端使用。3. 具体策略(Concrete Strategies)：这些是实现策略接口的类。每个具体策略封装了上下文可以使用的特定算法。2. 策略(Strategy)：这是一个接口或抽象类，定义了算法的契约。
Java设计模式-策略模式（支付业务的优化）
weixin_46421224的博客
11-09 1424
Java设计模式-策略模式
Java设计模式——策略模式
m0_60500421的博客
08-22 861
java策略模式
Java设计模式之策略模式
人生就像一场戏
03-25 1660
Java设计模式之策略模式
java 策略模式
11-15
策略模式是一种行为设计模式，它允许在运行时选择算法的行为。在策略模式中，我们创建表示各种策略的对象和一个上下文对象，该对象可以根据其策略对象的不同行为而更改其执行算法。 以下是Java中策略模式的示例代码： 首先，我们定义一个策略接口，该接口定义了一个方法calculate()，该方法将由具体策略类实现： ```java public interface Strategy { public int calculate(int num1, int num2); } ``` 然后，我们实现两个具体策略类，它们实现了策略接口并提供了自己的实现： ```java public class AddStrategy implements Strategy { public int calculate(int num1, int num2) { return num1 + num2; } } public class SubtractStrategy implements Strategy { public int calculate(int num1, int num2) { return num1 - num2; } } ``` 接下来，我们定义一个上下文类，该类将使用策略接口来执行算法： ```java public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public int executeStrategy(int num1, int num2) { return strategy.calculate(num1, num2); } } ``` 最后，我们可以在客户端代码中使用上下文对象来执行算法： ```java public class Client { public static void main(String[] args) { Context context = new Context(new AddStrategy()); System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); context = new Context(new SubtractStrategy()); System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); } } ``` 输出结果为： ``` 10 + 5 = 15 10 - 5 = 5 ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值