软件工程第三次作业 结对编程

最新推荐文章于 2024-07-18 11:27:31 发布
最新推荐文章于 2024-07-18 11:27:31 发布
阅读量117 收藏
点赞数
文章标签： 测试 java
原文链接：http://www.cnblogs.com/ghnb/p/8646789.html
版权

结对编程

小组成员：

201521123055 林一心 博客地址

201521123046 张杭镖 博客地址

项目地址

一、分析改进现有代码

1109682-20180325200542281-310965413.png

1109682-20180325200618346-1051169043.png

1.单元测试：

1109682-20180325200509613-965177584.png

2.覆盖率：

1109682-20180325200515875-1914315732.png

3.确定当前设计的一个弱点，通过重构，确保在这个地方已有测试覆盖并保证重构没有改变已有的功能：

原程序只能生成两个数之间的算式，并且分数与整数算式出现几率没设置正确。

4.修改代码后，检查代码覆盖，看单元测试是否需要修改？测试用例是否需要增加？

单元测试需要修改，因为添加了多个数字的运算。

二、功能扩展

增加了括号运算符，相应的计算函数也要添加括号运算符的处理，原代码把计算过程放在main生成算式的main类中处理，扩展功能后代码显得臃肿，因此单独把计算功能拉出来做一个Calculator类。（这个计算功能同样也支持多位整数的计算，以便小学生升级到进阶地狱）

核心代码：

生成题目

        
    public main()//生成四则运算并输出
    {
        new Thread(myTimeRunable).start();
        int n = 0;
        MainFrame ma= new MainFrame();


        try{
            //调用初始化方法
            jbInit();
        }
        catch(Exception exception){
            exception.printStackTrace();
        }

        try{

            n= Integer.parseInt(ma.number);

            }catch(NumberFormatException e){
                //利用消息对话框提示输入失败
                JOptionPane.showMessageDialog(this,"输入错误！请重新输入");
                }

            int m = (int)(Math.random()*n+1);//随机整数题目和分数题目的题量

            for(int j=0;j<(n-m);j++){//整数题目
                int no=(int)(Math.random()*3+1); //最多四个数字运算
                StringBuffer qustr=new StringBuffer("");
                String ans;
                int numm=(int)(Math.random()*9+1);//随机数字

                qustr.append(numm);

                for(int i=0;i<no;i++){
                    numm=(int)(Math.random()*9+1);
                    int op=(int)(Math.random()*4+1);//随机选择计算符

                    if(op==1){//加法
                        qustr.append("+"+numm);
                        //Answer.add(num1+num2+"");
                    }
                    if(op==2){
                        qustr.append("-"+numm);
                    }

                    if(op==3){//乘法
                        qustr.append("*"+numm);
                    }
                    if(op==4){//除法
                        i--;
                        continue;
                    }
                }
                if(no>=2) {
                    int left_kuo = (int) (Math.random() * no  + 1);
                    int right_kuo = (int) (Math.random() * (no+1 - left_kuo) + 1 + left_kuo);
                    qustr.insert(2*(left_kuo-1), '(');
                    qustr.insert(2*right_kuo, ')');
                }
                qustr.append('=');
                Question.add(qustr.toString());
                Calculator cal=new Calculator();
                Answer.add(""+cal.caculate(qustr.toString()));
            }







        for(int j=0;j<m;j++){//分数题目
               Scanner in = new Scanner(System.in);//真分数的计算
               int op=(int)(Math.random()*4+1);
               int[] f1 =createFraction();
               int[] f2 =createFraction();
               int j1=GCD(f1[0],f1[1]);
               f1[0]=f1[0]/j1;//化简分数
               f1[1]=f1[1]/j1;
               j1=GCD(f2[0],f2[1]);
               f2[0]=f2[0]/j1;
               f2[1]=f2[1]/j1;
               int gbs = LCM(f1[1],f2[1]);

             if(op==1){//加法
                  Question.add("("+f1[0]+"/"+f1[1]+")+("+f2[0]+"/"+f2[1]+")=");
                  int num1=f1[0]*f2[1]+f2[0]*f1[1];
                  int num2=f1[1]*f2[1];
                  int num3=GCD(num1,num2);
                  num1=num1/num3;
                  num2=num2/num3;
                  String a=new String();
                  if(num1==num2)
                    {
                        a="1";
                    }
                    else {
                      a = num1 + "/" + num2;
                  }
                  Answer.add(a+"");

              }
               if(op==2){//减法
                   int num1=f1[0]*f2[1]-f2[0]*f1[1];
                   if(num1>0){  //防止出现负数
                     Question.add("("+f1[0]+"/"+f1[1]+")-("+f2[0]+"/"+f2[1]+")=");
                     int num2=f1[1]*f2[1];
                     String a=new String();
                     if(num1==0)
                        {
                            a="0";
                        }
                        else
                        {
                        int num3=Math.abs(GCD(num1,num2));
                        num1=num1/num3;
                        num2=num2/num3;
                        if(num1==num2)
                        {
                            a="1";
                        }
                        else
                        {
                            a=num1+"/"+num2;
                        }
                        }
                     Answer.add(a+"");
               }else{
                   Question.add("("+f2[0]+"/"+f2[1]+")-("+f1[0]+"/"+f1[1]+")=");
                     int num11=f2[0]*f1[1]-f1[0]*f2[1];
                     int num2=f1[1]*f2[1];
                     String a=new String();
                     if(num11==0)
                        {
                            a="0";
                        }
                        else
                        {
                            int num3=Math.abs(GCD(num11,num2));
                            num11=num11/num3;
                            num2=num2/num3;
                            if(num11==num2)
                            {
                                a="1";
                            }
                            else
                            {
                                a=num11+"/"+num2;
                            }
                        }
                      Answer.add(a+"");



               }
                  }
              if(op==3){//乘法
                     Question.add("("+f1[0]+"/"+f1[1]+")*("+f2[0]+"/"+f2[1]+")=");
                     int num1= f1[0]*f2[0];
                     int num2 = f1[1]*f2[1];
                     int num3=GCD(num1,num2);
                     String a=new String();
                     num1= num1/num3;
                     num2 = num2/num3;
                  if(num1==num2)
                        {
                            a="1";
                        }
                        else
                        {
                            a=num1+"/"+num2;
                        }
                     Answer.add(a+"");
                  }
              if(op==4){//除法
                     Question.add("("+f1[0]+"/"+f1[1]+")÷("+f2[0]+"/"+f2[1]+")=");
                     int num1= f1[0]*f2[1];
                     int num2 = f1[1]*f2[0];
                     int num3=GCD(num1,num2);
                     String a=new String();
                     num1= num1/num3;
                     num2 = num2/num3;
                     if(num1==num2)
                        {
                            a="1";
                        }
                        else
                        {
                            a=num1+"/"+num2;
                        }
                     Answer.add(a+"");
              }
        }

        //输出题目
        JTextArea0.setText("");
        for(String string : Question){
            num ++;
            JTextArea0.append("("+num+")、"+string+"\n");
        }
    }

计算

    public class Calculator {


                private Stack<Long> numberStack = null;

                private Stack<Character> symbolStack = null;

                
                public long caculate(String numStr) {


                    // 初始化栈
                    numberStack = new Stack<Long>();
                    symbolStack = new Stack<Character>();
                    // 用于缓存数字，因为数字可能是多位的
                    StringBuffer temp = new StringBuffer();
                    // 从表达式的第一个字符开始处理
                    for (int i = 0; i < numStr.length(); i++) {
                        char ch = numStr.charAt(i); // 获取一个字符
                        if (isNumber(ch)) { // 若当前字符是数字
                            temp.append(ch); // 加入到数字缓存中
                        } else { // 非数字的情况
                            String tempStr = temp.toString(); // 将数字缓存转为字符串
                            if (!tempStr.isEmpty()) {
                                long num = Long.parseLong(tempStr); // 将数字字符串转为长整型数
                                numberStack.push(num); // 将数字压栈
                                temp = new StringBuffer(); // 重置数字缓存
                            }
                            // 判断运算符的优先级，若当前优先级低于栈顶的优先级，则先把计算前面计算出来
                            while (!comparePri(ch) && !symbolStack.empty()) {
                                long b = numberStack.pop(); // 出栈，取出数字，后进先出
                                long a = numberStack.pop();
                                // 取出运算符进行相应运算，并把结果压栈进行下一次运算
                                switch ((char) symbolStack.pop()) {
                                    case '+':
                                        numberStack.push(a + b);
                                        break;
                                    case '-':
                                        numberStack.push(a - b);
                                        break;
                                    case '*':
                                        numberStack.push(a * b);
                                        break;
                                    case '/':
                                        numberStack.push(a / b);
                                        break;
                                    default:
                                        break;
                                }
                            } // while循环结束
                            if (ch != '=') {
                                symbolStack.push(new Character(ch)); // 符号入栈
                                if (ch == ')') { // 去括号
                                    symbolStack.pop();
                                    symbolStack.pop();
                                }
                            }
                        }
                    } // for循环结束

                    return numberStack.pop(); // 返回计算结果
                }

            
                private String removeStrSpace(String str) {
                    return str != null ? str.replaceAll(" ", "") : "";
                }

                private boolean isStandard(String numStr) {
                    if (numStr == null || numStr.isEmpty()) // 表达式不能为空
                        return false;
                    Stack<Character> stack = new Stack<Character>(); // 用来保存括号，检查左右括号是否匹配
                    boolean b = false; // 用来标记'='符号是否存在多个
                    for (int i = 0; i < numStr.length(); i++) {
                        char n = numStr.charAt(i);
                        // 判断字符是否合法
                        if (!(isNumber(n) || "(".equals(n + "") || ")".equals(n + "")
                                || "+".equals(n + "") || "-".equals(n + "")
                                || "*".equals(n + "") || "/".equals(n + "")
                                || "=".equals(n + ""))) {
                            return false;
                        }
                        // 将左括号压栈，用来给后面的右括号进行匹配
                        if ("(".equals(n + "")) {
                            stack.push(n);
                        }
                        if (")".equals(n + "")) { // 匹配括号
                            if (stack.isEmpty() || !"(".equals((char) stack.pop() + "")) // 括号是否匹配
                                return false;
                        }
                        // 检查是否有多个'='号
                        if ("=".equals(n + "")) {
                            if (b)
                                return false;
                            b = true;
                        }
                    }
                    // 可能会有缺少右括号的情况
                    if (!stack.isEmpty())
                        return false;
                    // 检查'='号是否不在末尾
                    if (!("=".equals(numStr.charAt(numStr.length() - 1) + "")))
                        return false;
                    return true;
                }

            
                private boolean isNumber(char num) {
                    if (num >= '0' && num <= '9')
                        return true;
                    return false;
                }

                
                private boolean comparePri(char symbol) {
                    if (symbolStack.empty()) { // 空栈返回ture
                        return true;
                    }


                    char top = (char) symbolStack.peek();
                    if (top == '(') {
                        return true;
                    }
                    // 比较优先级
                    switch (symbol) {
                        case '(': // 优先级最高
                            return true;
                        case '*': {
                            if (top == '+' || top == '-') // 优先级比+和-高
                                return true;
                            else
                                return false;
                        }
                        case '/': {
                            if (top == '+' || top == '-') // 优先级比+和-高
                                return true;
                            else
                                return false;
                        }
                        case '+':
                            return false;
                        case '-':
                            return false;
                        case ')': // 优先级最低
                            return false;
                        case '=': // 结束符
                            return false;
                        default:
                            break;
                    }
                    return true;
                }


            }

运行结果：

1109682-20180325200702348-413295576.png

效能分析：

1109682-20180325200709441-248377915.png

三、小结感受

1109682-20180325200806565-698206896.jpg

结队编程在大二学习JAVA时有尝试过，只是初步体验了一下，这次与大佬结队希望真的能够学到东西提升自己，有个领航员，可以时刻发现问题。两人一起寻找问题发现问题感觉效率比较高，但编程过程还是比较坎坷，希望最后能够一加一大于二，乃至远大于二。

PSP2.1个人开发流程预估耗费时间（分钟）实际耗费时间（分钟）
Planning计划158
Estimate明确需求和其他相关因素，估计每个阶段的时间成本104
Development开发120140
Analysis需求分析需求分析 (包括学习新技术)1010
Design Spec生成设计文档00
Design Review设计复审108
Coding Standard代码规范22
Design具体设计1015
Coding具体编码4060
Code Review代码复审2010
Test测试（自我测试，修改代码，提交修改）1515
Reporting报告1512
·测试报告22
·计算工作量1510
·并提出过程改进计划105

转载于:https://www.cnblogs.com/ghnb/p/8646789.html

baer20141118
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PairProject:W班软件工程实践结对第二次作业仓库
04-01
结对第二次作业-顶会热词统计的实现为了不遗漏作业内容，这里有一个清单检查表方便同学们快速检阅。fork仓库，和伙伴商讨如何通过github协作/代码规范等编程实现功能一，操作爬取的论文列表功能二，爬取结果分析展示...
201521123055 结对编程作业
weixin_30793643的博客
03-25 93
结对编程 小组成员： 201521123055 林一心 博客地址 201521123046 张杭镖 博客地址 项目地址 一、分析改进现有代码 1.单元测试： 2.覆盖率： 3.确定当前设计的一个弱点，通过重构，确保在这个地方已有测试覆盖并保证重构没有改变已有的功能： 原程序只能生成两个数之间的算式，并且分数与整数算式出现几率没设置正确。 4.修改代码后，检查代码覆盖，看单元测试是否需要修改...
Java实现带括号优先级的计算器
weixin_30530523的博客
07-14 744
这个计算器不仅能够进行四则运算，还支持添加括号进行优先级计算，例如下面算式： 10+(2*16-20/5)+7*2=52 Java源代码： 1 import java.awt.BorderLayout; 2 import java.awt.Container; 3 import java.awt.event.ActionEvent; 4 import ...
第三次作业--结对编程
Logic99的博客
09-30 195
很小的一个点名系统
根据运算符优先级解析SQL规则表达式
weixin_33714884的博客
02-27 436
根据运算符优先级解析SQL规则表达式 目录 1.需求 2.知识准备 2.1 运算符优先级解析 2.2 流程分析 3.解决方案 3.1 思路1 3.2 思路2 正文 回到顶部 1.需求 测试数据库使用Greenplum，生产库使用GBase 普通表：存储客户数据，千万级别，结构如下 stat_date代表日期；user_i...
【清华】 软件工程（完） 视频.txt
05-24
第三部分介绍高级软件工程；第四部分介绍软件管理，重点介绍技术管理问题。 《软件工程(原书第9版)》适合作为软件和系统工程专业本科生或研究生教材，同时也是软件工程师难得的优秀参考书籍。 目录编辑 《软件工程...
2023年软件工程实践者的研究方法背诵知识点.doc
10-26
设计原则：KIS重构：以不改变代码外部行为而改善其内部构造的方式来修改软件系统的过程结对编程：两个人面对同一台计算机共同为一种故事开发代码。长处：结对的两人完毕其工作，他们所开的代码将与其他人工作集成。...
第六章 软件工程1
08-08
【第六章 软件工程1】 软件工程是软件开发过程中的系统化方法，它涵盖了需求分析、设计、编码、测试和维护等多个方面。在软件工程的第六章中，主要探讨了软件开发的关键概念和实践。 1. **功能需求与非功能需求**...
第一部分 软件工程与过程（第4章 案例研究).ppt
07-11
《第一部分 软件工程与过程（第4章 案例研究）》的讲解主要涉及了多种软件系统的分析和设计，包括出卷系统、短信系统、POS机系统、ATM机系统、图书馆系统以及分布式结对编程系统。这些案例涵盖了软件工程的不同方面...
HDU1000，HDU1001，HDU1002，HDU1003，HDU1004
u014114223的博客
07-17 1335
执行加法操作，根据两个数的长度选择较长的一个进行循环。在每次迭代中，将对应的位相加，同时加上来自更高位的进位（如果有的话），并将结果存储在。首先输出测试用例的编号，然后是原始的两个大整数（按照原始顺序输出），接着是等于号和加法的结果。使用循环将字符串中的数字转换为整数，并反向存储在。在不同的测试用例之间，输出一个空行以便区分。的长度减一，这是因为数组是从1开始索引的。等于0的情况，此时循环结束，程序随之结束。：最后，函数返回0，表示程序正常结束。，代表要相加的两个大整数。首先，读取测试用例的数量。
软件测试-测试用例设计方法（附实际项目用例）
最新发布
qq_61167424的博客
07-18 605
本篇文章主要介绍按照测试对象进行分类，设计测试用例的方法有哪些
软件测试——面试八股文（入门篇）
yjt2045263063的博客
07-15 1056
α测试：在受控的环境中进行，由用户在开发者的场所进行，并且在开发者对用户的指导下进行测试，开发者负责记录发现的错误和使用中遇到的问题β测试：在开发者不能控制的环境中的真实应用，由软件的最终用户们在一个或多个客户场所下进行，由用户记录在测试中遇到的一系列问题，并定期报给开发者。结语鉴于篇幅所限，选出经典17个软件测试面试题（入门篇）需要完整面经的朋友可以关注并私信我关键词“资料”免费领取。
外包干了1个月，技术明显退步。。。
HUA6911的博客
07-15 2571
什么都做了，和什么都没做其实是一样的，走出“瞎忙活”的安乐窝，才是避开弯路的最佳路径。希望我的经历能帮助到有需要的朋友，同时也给各位准备了一份资源，盘里头是一整套软件测试必备资料。
【框架】PHP框架详解-symfony框架
Xiaoxin的博客
07-16 813
1. 起源与开发者Symfony由SensioLabs（现为Symfony公司）开发，最初由Fabien Potencier于2005年创建。Symfony框架自发布以来，经历了多个版本的迭代，每个版本都引入了新的特性和改进，以满足不断变化的Web开发需求。2. 设计理念Symfony框架遵循MVC（Model-View-Controller）设计模式，将应用程序分为模型、视图和控制器三个核心部分，有助于实现代码的分离和重用。
测试类型介绍-兼容性测试策略与案例
java电商源码分享
07-16 455
兼容性测试，作为软件质量保证的重要环节，旨在确保应用程序在不同的环境（包括但不限于操作系统、浏览器、设备型号和屏幕分辨率）下能够正常运行并提供一致的用户体验。其核心目的是提升软件产品的市场适应性和用户满意度，减少因兼容性问题导致的用户流失。
10：00面试，10：08就出来了，问的问题有点变态。。。
qq_48811377的博客
07-17 804
整份文档一共有将近 200 页，全部为大家展示出来肯定是不太现实的，为了不影响大家的阅读体验就只展示了部分内容，还望大家海涵，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习！
【Playwright+Python】系列 Pytest 插件在Playwright中的使用
朱雀随云记的博客
07-14 819
对于browser和context夹具，请使用以下夹具来定义自定义启动选项。browser_type_launch_args：覆盖 browser_type.launch（） 的启动参数。它应该返回一个 Dict。browser_context_args：覆盖 browser.new_context（） 的选项。它应该返回一个 Dict。return {
软件技术(企业应用软件开发方向)实训室解决方案
whwzzc的博客
07-17 415
平台基于k8s实现公有云、混合云、私有云多种部署方式，提供在线html、css、js、jquery、vue等前端开发环境，实现真正的云开发，开箱即用，主要模块有课程制作工具、作业、活动、云盘、共享课、我的课、云优选课。软件开发实训室配备计算机、服务器、交换机、网络机柜、多媒体中控台、投影仪、投影幕、电脑桌椅、交互式电子白板、操作系统软件办公软件、Java项目开发软件、Android 项目开发软件、数据库开发软件、前端开发软件、Python 项目开发软件、.Net 项目开发软件、项目管理软件。
java之 junit单元测试案例【经典版】
健康平安的活着的专栏
07-17 233
I: Independent 独立性；2.单元测试必须使用assert来验证。A： automatic 自动化；R：Repeatable 可重复；单元测试要满足AIR原则，即。
结对编程实践：打造高质量软件开发
"孟雷的演讲PPT，主题是如何通过结对编程实现高质量的软件开发，主要探讨了软件研发模式的演变、开发与测试的困境、结对编程的原理与优势，以及实施结对编程的最佳实践。" 在软件开发领域，各种开发模型如瀑布模型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值