策略模式以及与简单工厂模式的结合

最新推荐文章于 2024-07-09 21:07:23 发布
最新推荐文章于 2024-07-09 21:07:23 发布
阅读量874 收藏 16
点赞数 24
分类专栏： 设计模式 文章标签： 策略模式 简单工厂模式 状态模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46896305/article/details/135881390
版权

（参考大话设计模式 程杰著）
在上一篇中，介绍了简单工厂模式，可以借今天的问题先回顾一下工厂模式。

问题：做一个商场收银软件，营业员根据客户购买的单价和数量，向客户收费。如图：在这里插入图片描述

你可能会想到，将前端界面写好，form表单提交给后端处理，返回给前端即可。的确，但是现在商场的营销策略变了，今天要打八折，明天要满300返100促销。由此，想让你用简单工厂来实现。

一、简单工厂实现

思路：不管是正常价格，打几折，还是返钱都可以看作是一种收钱方法。由此你可以想到可以把收钱方法抽象出来到父类，子类实现不同的收钱方法，再通过一个工厂，根据前端下拉框的内容来判断new什么子类对象，再通过多态调用某个具体的方法返回money，带到前端界面显示即可。下面是具体代码：

1.CashSuper类：

package com.shou.simplefactory.servlet;

//收费父类
abstract class CashSuper {
    public abstract double acceptCash(double money);
}

2.CashNormal类：

package com.shou.simplefactory.servlet;

//正常收费子类
public class CashNormal extends CashSuper{
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

3.CashRebate类：

package com.shou.simplefactory.servlet;

//打折收费子类
public class CashRebate extends CashSuper{
    private double moneyRebate=1d;

    public CashRebate() {
    }

    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double acceptCash(double money) {
        return money*moneyRebate;
    }
}

4.CashReturn类：

package com.shou.simplefactory.servlet;

//返利收费子类
public class CashReturn extends CashSuper{
    private double moneyCondition=0.0d;
    private double moneyReturn=0.0d;

    public CashReturn() {
    }

    public CashReturn(double moneyCondition, double moneyReturn) {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double acceptCash(double money) {
        if (money>=moneyCondition){
            money=money-Math.floor(money/moneyCondition)*moneyReturn;
        }
        return money;
    }
}

5.工厂类CashFactory（关键）：

package com.shou.simplefactory.servlet;

public class CashFactory {
    public static CashSuper createCashAccept(String str){
        CashSuper cashSuper=null;
        switch (str){
            case "正常收费":
                cashSuper=new CashNormal();
                break;
            case "打八折":
                cashSuper=new CashRebate(0.8);
                break;
            case "满300返100":
                cashSuper=new CashReturn(300,100);
                break;
        }
        return cashSuper;
    }
}

6.前端界面：

index2.jsp:

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2024/1/25
  Time: 0:46
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/tactics" method="post">
    <table>
        <thead>商场收银系统</thead>
        <tbody>
        <tr>
            <td>单价：</td>
            <th><input type="text" name="price"></th>
            <th><input type="submit" value="确定"></th>
        </tr>
        <tr>
            <td>数量：</td>
            <th><input type="text" name="count"></th>
            <th><input type="reset" value="重置"></th>
        </tr>
        <tr>
            <td>
                <label for="dropdown">选择结算方式：</label>
                <select id="dropdown" name="selectedValue">
                    <option value="正常收费">正常收费</option>
                    <option value="打八折">打八折</option>
                    <option value="满300返100">满300返100</option>
                </select>
            </td>
        </tr>
        <tr>
            <td colspan="3"><textarea>${list}</textarea></td>
        </tr>
        <tr>
            <td>总计： </td>
            <th>${total}</th>
        </tr>
        </tbody>

    </table>
</form>
</body>
</html>

7.处理前端界面的TacticsServlet：

package com.shou.simplefactory.servlet;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/tactics")
public class TacticsServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        String priceString=req.getParameter("price");
        double price=Integer.parseInt(priceString);
        System.out.println(price);
        String countString=req.getParameter("count");
        double count=Integer.parseInt(countString);
        //此处获取到的是下拉选项的value而不是内容
        String selectedValue=req.getParameter("selectedValue");
        //测试
        System.out.println(selectedValue);
        //（1）先通过工厂new出来具体的收费策略对象
        CashSuper cashSuper=CashFactory.createCashAccept(selectedValue);
        //（2）调用子类对象的具体收费方法
        double totalPrice=0d;
        totalPrice=cashSuper.acceptCash(price*count);

        //（3）返回到前端多文本框
        List<String> list=new ArrayList<>();
        list.add("单价："+price+"数量："+count+"合计："+totalPrice);
        req.setAttribute("list",list);

        //带到前端jsp界面，注意html是静态界面，不能用 RequestDispatcher dispatcher = request.getRequestDispatcher("/index2.jsp");
        req.setAttribute("total",totalPrice);
        RequestDispatcher dispatcher=req.getRequestDispatcher("/index2.jsp");
        dispatcher.forward(req,resp);

        System.out.println("总价为："+totalPrice);
    }
}

由此功能基本完成：在这里插入图片描述

有了这个“收费对象生成工厂”，若再有其他的促销手段，即可在工厂类中增加一个分支，客户端和servlet改动一下即可。
但这里会有一个问题：简单工厂能解决这个问题，但这个模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场可能经常更改打折额度和返利额度，每次维护和扩展收费方式都要改动这个工厂，以致代码重新编译部署，并不是最好的方法。由此引入今天的主角：策略模式

策略模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，次模式让算法的变化，不会影响到使用的客户。

商场收银的促销，都是一些算法。用工厂生成算法对象没错，但算法本身只是一种策略，最重要的是算法随时可能相互替换，这就是变化点。
下面是策略模式的结构图：请添加图片描述

二、策略模式实现

根据这个结构图，我们不难模仿写出这个CashContext类（Cash Super、CashNormal、CashRebate、CashReturn都不用改）。请添加图片描述
1.CashContext类：

package com.shou.tactics.servlet;

//替代工厂类

public class CashContext {
    private CashSuper cs;

    //通过 [构造方法] 传入具体的收费策略
    public CashContext(CashSuper csuper){
        this.cs=csuper;
    }
    public double GetResult(double money){
        return cs.acceptCash(money);
    }
}

2.servlet类：

package com.shou.tactics.servlet;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/client")
public class Client extends HttpServlet {
    CashContext cashContext=null;

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        String priceString=req.getParameter("price");
        double price=Integer.parseInt(priceString);
        System.out.println(price);
        String countString=req.getParameter("count");
        double count=Integer.parseInt(countString);
        //此处获取到的是下拉选项的value而不是内容
        String selectedValue=req.getParameter("selectedValue");
        //测试
        System.out.println(selectedValue);

        switch (selectedValue){
            case "正常收费":
                cashContext=new CashContext(new CashNormal());
                break;
            case "打八折":
                cashContext=new CashContext(new CashRebate(0.8));
                break;
            case "满300返100":
                cashContext=new CashContext(new CashReturn(300,100));
                break;
        }
        double total=0d;
        total=cashContext.GetResult(count*price);

        List<String> list=new ArrayList<>();
        list.add("单价："+price+"数量："+count+"合计："+total);
        req.setAttribute("list",list);
        req.setAttribute("total",total);

        RequestDispatcher dispatcher=req.getRequestDispatcher("/index2.jsp");
        dispatcher.forward(req,resp);

    }
}

这样明显没怎么改进，需要将判断的过程从servlet移走，可以想到策略模式与工厂模式结合，即在CashContext中进行过程判断。

三、策略与简单工厂结合

1.改进后的CashContext类：

package com.shou.improve.tactics.servlet;

//替代工厂类

public class CashContext {
    CashSuper cs=null;

    public CashContext(String type){
        switch (type){
            case "正常收费":
                CashNormal cs0=new CashNormal();
                cs=cs0;
                break;
            case "打八折":
                CashRebate cs1=new CashRebate(0.8);
                cs=cs1;
                break;
            case "满300返100":
                CashReturn cs2=new CashReturn(300,100);
                cs=cs2;
                break;
        }
    }

    public double GetResult(double money){
        return cs.acceptCash(money);
    }
}

2.servlet类：

package com.shou.improve.tactics.servlet;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet("/improveclient")
public class Client extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        String priceString=req.getParameter("price");
        double price=Integer.parseInt(priceString);
        System.out.println(price);
        String countString=req.getParameter("count");
        double count=Integer.parseInt(countString);
        //此处获取到的是下拉选项的value而不是内容
        String selectedValue=req.getParameter("selectedValue");
        //测试
        System.out.println(selectedValue);

        //!这里只需要让客户端认识这一个CashContext类即可，
        // 不需要像简单工厂一样，将字符串先给工厂，返回具体的子类对象（CashSuper cashSuper=CashFactory.createCashAccept(selectedValue);）
        CashContext cashContext1=new CashContext(selectedValue);

        double total=0d;
        total=cashContext1.GetResult(count*price);


        List<String> list=new ArrayList<>();
        list.add("单价："+price+"数量："+count+"合计："+total);
        req.setAttribute("list",list);
        req.setAttribute("total",total);

        RequestDispatcher dispatcher=req.getRequestDispatcher("/index2.jsp");
        dispatcher.forward(req,resp);

    }
}

至此，我们可以只让客户端认识CashContext类即可，不用像简单工厂一样要认识CashSuper和CashFactory类，降低了耦合度。
对比不同：
请添加图片描述

当然这个模式解决这个问题并不是最完美的，因为在CashContext中依然有switch来判断，增加条件进行更改的麻烦，后面抽象工厂模式进行讲解。
关注我不迷路~

坚持不懈的ape
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java策略模式 工厂模式_策略模式与简单工厂模式的结合使用
weixin_42164534的博客
02-17 891
Java设计模式中的策略模式(Strategy Patten)定义了一组算法，将每个算法都封装起来，并且可使它们之间可以相互替换，在客户端调用它们时可以互不影响。策略模式主要由三个角色组成1、抽象策略角色：通常是一个接口或抽象类实现，我们的具体策略类就是继承或实现这个抽象角色。2、具体策略角色：我们在这些类中写策略和算法，继承或实现抽象策略角色。3、环境角色：环境角色中拥有一个抽象策略角色的引用，...
策略模式+工厂模式解决问题demo
03-30
将策略模式和工厂模式结合使用，可以构建出一个灵活且易于维护的折扣管理模块。工厂可以根据需求动态地创建策略对象，而策略对象则负责执行具体的折扣计算逻辑。这种设计使得添加新的折扣策略变得简单，只需要创建新...
设计模式：策略模式和工厂模式混合使用
qq_27586963的博客
09-19 838
需要根据具体的应用场景和需求来权衡使用策略模式和工厂模式的混合。在某些情况下，这种组合可以提供更灵活、可扩展和可维护的设计，但也需要考虑代码复杂性和类的数量增加的影响。
Java设计模式之策略模式+工厂模式+模板模式
心若有向往，何惧道阻且长！
10-19 6463
Java设计模式之策略模式+工厂模式+模板模式
Java 工厂模式 加 策略模式
real_rookie的博客
08-20 1084
JAVA 工厂模式 + 策略模式
策略模式+工厂模式的使用
weixin_42202992的博客
12-07 298
在项目开发过程中,经常会遇到项目代码中充斥着大量的if-else,每次增加类型都要整体代码逻辑看一遍才可以修改,当业务逻辑不变时使用以上代码是没有什么问题的,但业务经常变动时,就需要经常改动代码,如果后期再增加分支,每次改动都需要对每个分支都做测试,增加测试工作量同时要不利于代码维护,也违反开闭原则和单一职责,这时候我们就要想办法来优化这样的代码.代码改造:下面我们使用策略模式+工厂来改造以上代码
工厂+策略模式
weixin_73535718的博客
03-29 612
在软件开发中，工厂模式和策略模式常常结合使用，特别适用于根据不同情况选择不同的处理方式的场景。举例来说，假设您正在开发一个考试系统，系统中有不同类型的题目，如选择题、填空题、判断题等，每种题目类型需要不同的处理方式。/*** 枚举身份的识别*//*** 实际的题目的插入*/
设计模式(策略与简单工厂结合_排序)手写代码
03-20
本篇文章将聚焦于两种重要的设计模式——策略模式和简单工厂模式，并探讨如何将它们结合应用于排序算法的实现。 **策略模式**是一种行为设计模式，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其...
策略模式与工厂模式结合.rar
06-11
GOOD:客户端只需访问 Context 类，而不用知道其它任何类信息，实现了低耦合。
单例、工厂、策略模式C++、qt
01-01
例如，你可以使用单例模式管理Qt应用程序的全局设置，工厂模式用于动态创建和管理不同类型的设备（如device文件中可能包含的各种硬件设备），而策略模式则可用于处理设备的多种工作模式或策略。 通过这样的设计，你...
策略模式 + 抽象工厂实现多方式登录验证
06-24
总的来说，这个示例展示了如何结合策略模式和抽象工厂模式来设计一个灵活的多方式登录验证系统。策略模式确保了每种登录方式的独立性，而抽象工厂模式则负责根据需求动态地创建和切换这些策略，提供了良好的扩展性和...
工厂模式和策略模式的综合使用
热门推荐
张彦峰的博客
06-24 2万+
其实在很多的开发设计中，将工厂模式和策略模式的综合使用的案例是很多的，而且解决的实际问题也一样很多，本次对基本的简单工厂模式和策略模式做简单介绍，重点放在两者结合后的具体应用上做分析和讲解。
工厂模式+策略模式 示例
m0_46211448的博客
04-01 1165
项目案例，工厂模式+策略模式实战
微服务项目 工厂+策略模式 以及案例
dhsjdh124的博客
03-28 2002
在微服务项目中，策略加工厂模式是一种设计模式，用于解决在不同情况下需要使用不同策略的问题。该模式结合了策略模式和工厂模式的特点，使得系统更具灵活性和可扩展性。
Java设计模式 | 基于订单批量支付场景，对策略模式和简单工厂模式进行简单实现
程序员雅痞的博客
10-19 1303
使用策略模式+简单工厂模式 模拟批量支付场景。
设计模式使用简例（简单工厂+策略模式+模板方法）
最新发布
weixin_54925172的博客
07-09 494
直接上代码，方便记忆。主要的要点，已经写到注释中。
【Java 开发】策略+工厂模式使用模版
人生苦短，我用python
01-10 466
使用策略 + 工厂设计模式可以有效地简化大量的 if-else 逻辑。通过定义统一的策略接口和多个具体策略实现，结合工厂类进行管理，实现了代码的高内聚低耦合。这样，根据不同的需求类型，可以灵活地切换策略，提高了代码的可维护性和可扩展性。
（2）设计模式之 策略模式 及 策略模式与简单工厂模式的结合
m0_55759099的博客
04-26 1028
策略模式 策略模式：它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。 我们继续以例子来阐述该模式 假如商场搞促销，有多种促销方式，促销方式包括：满300送80，打8折，满500送150等等，现在要求写出一个商场收银软件的的逻辑代码 其实这个要求用前面说过的简单工厂模式也一样可以实现，直白的说，简单工厂模式和策略模式的差别很小，而策略模式和简单工厂模式结合起来与简单工厂模式自身比较的话，差距一般人看不出来… 如果用简单工厂模式来写，很简单，跟写计算器差不
大话设计模式-Java实现（2）-策略模式
qq_44458489的博客
03-14 189
v1.0 import java.util.Scanner; //商场收银软件 //营业员根据客户所购买商品的单价和数量进行收费 public class Program1 { public static void main(String[] args) { //声明一个double变量total来计算总计 double tot...
设计模式之简单工厂模式与策略模式
05-18
简单工厂模式和策略模式都是常用的设计模式，它们都属于对象创建型模式。 简单工厂模式是一种工厂模式，它通过一个工厂类来创建不同的对象。这些对象都继承自同一个父类或接口，工厂类根据不同的参数来创建不同的对象实例。简单工厂模式适用于对象的创建比较简单的情况下，可以将对象的创建和使用分离，提高代码的可维护性和可扩展性。 策略模式是一种行为型模式，它定义了一系列算法，将每个算法封装起来，使它们之间可以相互替换。这种模式使得算法可以独立于使用它的客户端而变化。策略模式适用于需要动态切换算法的情况下，可以减少代码的冗余和复杂度。 简单工厂模式和策略模式的区别在于它们的应用场景不同。简单工厂模式适用于对象的创建比较简单的情况下，而策略模式适用于需要动态切换算法的情况下。同时，简单工厂模式是一种创建型模式，而策略模式是一种行为型模式。在实际应用中，两种模式也可以结合使用，比如在策略模式中使用简单工厂模式来创建不同的策略对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值