结对编程项目-四则运算阶段性总结

时间 2019-11-10

标签编程项目四则运算阶段性总结繁體版

原文原文链接

结对编程项目-四则运算阶段性总结

在这段时间的结对编程过程当中，我和个人组员一同编程，初步完成了项目的要求，如今我将阶段性的成果作一个总结

1、需求分析

实现一个命令行程序，要求：git

一、自动生成小学四则运算题目(加、减、乘、除)
二、支持整数
三、支持多运算符（好比生成包含100个运算符的题目）
四、支持真分数
五、统计正确率

从题目要求可知，咱们须要实现如下几个功能：express

随机生成个四则运算题目，并可手动控制生成的题目数目
能将计算的结果转化为分数
自动计算生成题目的结果，并能判断用户输入是否与运算结果相同

现阶段已实现要求二、3，要求4虽已初步实现但仍存在一些问题，咱们将会在下一阶段中实现全部项目要求的功能，并可拓展如下功能：编程

随机生成题目
题目去重
生成题目后从文件读入并判题

2、设计思路

根据需求，考虑程序须要定义方法来实现中缀表达式转后缀表达式、后缀式计算的功能，将结果转换为分数以及须要定义调用以上三种种方法并进行输入输出的主类，因而我将前两种方法放入MyDC的类中，真数的支持放入Rational类中，主类设置为MyDCTester。数组

一、将输入的中缀表达式转化为后缀表达式

运用老师在博客中提供的法则：post

若是遇到数字，咱们就直接将其输出。
若是遇到非数字时，若栈为空或者该符号为左括号或者栈顶元素为括号，直接入栈。
若是遇到一个右括号，持续出栈并输出符号，直到栈顶元素为左括号，而后将左括号出栈（注意，左括号只出栈，不输出），右括号不入栈。
若是遇到运算符号且栈非空，查看栈顶元素，若是栈顶元素的运算优先级大于或者等于该运算符号，则持续出栈，直到栈顶元素优先级小于该运算符。最后将该元素入栈。
若是咱们读到了输入的末尾，则将栈中全部元素依次弹出。
使用if-else以及switch语句在程序中实现该规律。
在程序中我使用了字符串栈stacktwo，并定义了trans方法实现功能，代码以下：

public String trans(String before){
        int i,j=0;
        char step[] = before.toCharArray();//将中缀式字符串转化为字符数组
        char after[] = new char[step.length];//用于接收转化后的后缀式表达式
        for(i=0;i<step.length;i++) {
            if (step[i] >= '0' && step[i] <= '9') {//遇到数字
                after[j] = step[i];
                j++;
                if(i==(step.length)-1){//读到了输入的末尾
                    while(stacktwo.empty()==false) {
                        after[j]=stacktwo.pop();
                        j++;
                    }
                }
            }
            else if(stacktwo.empty()||step[i]=='('||stacktwo.peek()=='('||stacktwo.peek()==')') {//遇到非数字且栈为空或者该符号为左括号或者栈顶元素为括号
                stacktwo.push(new Character(step[i]));
                if(i==(step.length)-1){
                    while(stacktwo.empty()==false) {
                        after[j]=stacktwo.pop();
                        j++;
                    }
                }
            }
            else if(step[i]==')') {//遇到一个右括号
                while (stacktwo.peek() != '(') {
                    after[j] = stacktwo.pop();
                    j++;
                }
                stacktwo.pop();
                if(i==(step.length)-1){
                    while(stacktwo.empty()==false) {
                        after[j]=stacktwo.pop();
                        j++;
                    }
                }
            }
            else {//遇到运算符号且栈非空
                switch (step[i]) {
                    case ADD:
                    case SUBTRACT:
                    {
                        while(stacktwo.peek()=='*'||stacktwo.peek()=='/'||stacktwo.peek()=='+'||stacktwo.peek()=='-'){
                            after[j]=stacktwo.pop();
                            j++;
                            if(stacktwo.empty()){
                                break;
                            }
                        }
                        stacktwo.push(step[i]);
                        break;
                    }
                    case MULTIPLY:
                    case DIVIDE:
                    {
                        while(stacktwo.peek()=='*'||stacktwo.peek()=='/'){
                            after[j]=stacktwo.pop();
                            j++;
                            if(stacktwo.empty()){
                                break;
                            }
                        }
                        stacktwo.push(step[i]);
                        break;
                    }
                }
                if(i==(step.length)-1){
                    while(stacktwo.empty()!=false) {
                        after[j]=stacktwo.pop();
                        j++;
                    }
                }
            }
        }
        String str = new String(after);
        return str;//将字符数组转化为字符串后返回
    }

二、后缀式表达式的运算。

老师给的连接中已经明确给出了计算的方法，方法以下：学习

设置一个操做数栈，开始栈为空；
从左到右扫描后缀表达式，遇操做数，进栈；
若遇运算符，则从栈中退出两个元素，先退出的放到运算符的右边，后退出的放到运算符左边，运算后的结果再进栈，直到后缀表达式扫描完毕。
在程序中我以老师给的代码例子为基础，加以本身的理解，使用了整型栈stack，并定义了evaluate以及evalSingleOp方法来实现功能，代码以下：

public int evaluate(String expr) {//计算后缀式的值
        int op1, op2, result = 0,i;
        char token[]=expr.toCharArray();//将后缀式字符串转化为字符数组
        for(i=0;i<token.length;i++){
            if (token[i]=='+' || token[i]=='-' || token[i]=='*' || token[i]=='/') {//对每一个字符进行分析，若是是运算符就取出栈顶开始的两个数
                op2 = stack.pop();
                op1 = stack.pop();
                result = evalSingleOp(token[i], op1, op2);//将栈中取出的两个数进行运算
                stack.push(new Integer(result));//将结果压栈
            } else//为数字时直接进栈
                stack.push(new Integer((int)(token[i]-'0')));
        }

        return result;//返回计算结果
    }

    private int evalSingleOp(char operation, int op1, int op2) {//对栈中取出的两个数进行四则运算，operation为后缀式中的运算符号
        int result = 0;

        switch (operation) {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }

        return result;//返回运算结果
    }

三、支持真分数

咱们经过学习教材上第100页的例子22封装了有理数类Rational，实现了对真分数的支持。
代码以下：测试

public class Rational {
    int numerator = 1;//分子
    int denominator = 1;//分母
    void setNumerator(int a) {//设置分子
        int c = f(Math.abs(a), denominator);//计算最大公约数
        numerator = a / c;
        denominator = denominator / c;
        if (numerator < 0 && denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
    }
    void setDenominator(int b) {//设置分母
        int c = f(numerator, Math.abs(b));//计算最大公约数
        numerator = numerator / c;
        denominator = b / c;
        if (numerator < 0 && denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        } else if (numerator > 0 && denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
    }

    int getNumerator() {
        return numerator;
    }

    int getDenominator() {
        return denominator;
    }

    int f(int a, int b) {//求a,b的最大公约数
        if (a == 0) {
            return 1;//c为分母不能为0
        }
        if (a < b) {//令a>b
            int c = a;
            a = b;
            b = c;
        }
        int r = a % b;
        while (r != 0) {
            a = b;
            b = r;
            r = a % b;
        }
        return b;
    }

    Rational add(Rational r) {//加法运算
        int a = r.getNumerator();//返回有理数r的分子
        int b = r.getDenominator();//返回有理数r的分母
        int newNumerator = numerator * b + denominator * a;//计算出新分子
        int newDenominator = denominator * b;//计算出新分母
        Rational result = new Rational();
        result.setNumerator(newNumerator);
        result.setDenominator(newDenominator);
        return result;
    }

    Rational sub(Rational r) {//减法运算
        int a = r.getNumerator();
        int b = r.getDenominator();
        int newNumerator = numerator * b - denominator * a;
        int newDenominator = denominator * b;
        Rational result = new Rational();
        result.setNumerator(newNumerator);
        result.setDenominator(newDenominator);
        return result;
    }

    Rational muti(Rational r) {//乘法运算
        int a = r.getNumerator();
        int b = r.getDenominator();
        int newNumerator = numerator * a;
        int newDenominator = denominator * b;
        Rational result = new Rational();
        result.setNumerator(newNumerator);
        result.setDenominator(newDenominator);
        return result;
    }

    Rational div(Rational r) {//除法运算
        int a = r.getNumerator();
        int b = r.getDenominator();
        Rational result = new Rational();
        if (a == 0) {
            System.out.println("分母不能为0");
            result.setNumerator(0);
            System.exit(0);
        } else {
            int newNumerator = numerator * b;
            int newDenominator = denominator * a;
            result.setNumerator(newNumerator);
            result.setDenominator(newDenominator);
        }
        return result;
    }
}

四、调用方法并实现输入输出

现阶段为减小程序调试的难度，咱们使用了老师在博客中提供的代码，但老师提供的代码没法实现随机生成题目、支持真分数以及统计正确率的功能，因而咱们作出了修改，使得程序能够支持分数输出，在接下来的编程中咱们会根据需求对这部分代码进行从新编写。编码

public class MyDCTester {
    public static void main(String[] args) {

        String expression, again;

        Rational result=new Rational();

        try {
            Scanner in = new Scanner(System.in);

            do {
                MyDC evaluator = new MyDC();
                System.out.println("Enter a valid postfix expression: ");
                expression = in.nextLine();//输入运算表达式
                result = evaluator.evaluate(evaluator.trans(expression));//调用trans方法以及evaluate方法进行转化以及输出计算结果
                System.out.println();
                int a=result.getNumerator();
                int b=result.getDenominator();
                if (b==1){//分数转换
                    System.out.println("result="+a);
                }
                else{
                    System.out.println("result="+a+"/"+b);
                }
                System.out.print("Evaluate another expression [Y/N]? ");//询问用户是否再次计算
                again = in.nextLine();
                System.out.println();
            }
            while (again.equalsIgnoreCase("y"));
        } catch (Exception IOException) {
            System.out.println("Input exception reported");
        }

五、UML类图

3、实现过程当中的关键代码解释

我已在设计思路部分给出了设计思路并对关键代码进行了注释。lua

4、运行过程截图

5、代码托管地址

码云连接命令行

6、遇到的困难及解决方法

到目前为止的困难主要在于实现中缀表达式转化为后缀表达式以及分数的转化，我将一些细节的问题写在了下面。

问题一：不知如何将字符串转化为字符数组
问题一解决办法：翻书时注意到书上第八章的toCharArray()方法能够实现该转化过程。
问题二：在命令行中编译程序时遇到如图所示的问题
问题二解决办法：使用-Xlint:deprecation命令进行编译，找到问题并修改。

7、对结对的小伙伴作出评价

个人结对搭档是江野，在合做的过程当中我是牵头人，他也积极响应个人号召，在编程过程当中咱们互相学习，在遇到困难时一块儿讨论解决办法。但愿能在之后的任务中继续合做，也但愿搭档能更加积极地参与到项目中。

8、PSP

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划
· Estimate	· 估计这个任务须要多少时间	15	30
Development	开发
· Analysis	· 需求分析 (包括学习新技术)	25	35
· Design Spec	· 生成设计文档	30	30
· Design Review	· 设计复审 (和同事审核设计文档)	20	30
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	35	45
· Design	· 具体设计	60	80
· Coding	· 具体编码	150	200
· Code Review	· 代码复审	30	35
· Test	· 测试（自我测试，修改代码，提交修改）	20	35
Reporting	报告	60	80
· Size Measurement	· 计算工做量	10	20
· Postmortem & Process Improvement Plan	· 过后总结, 并提出过程改进计划	20	20
	合计	475	640