结对项目第一周总结

结对项目——四则运算 阶段性总结

一、需求分析（第一周达成）：

• 能够生成n道四则运算题，n可由使用者输入来控制
• 支持整数
• 支持分数
• 生成题目中含有括号
• 可以判断正误，如果错误会输出正确答案
• 统计正确率

---

扩展需求：

• 生成题目后存入文件
• 完成题目后从文件读入并进行判断
• 支持题目去重
• 支持繁體中文，简体中文，English

二、设计思路（同时输出UML类图）：

以下是程序主体设计思路，各步骤具体操作详情请见注释：
由于本周可用的准备时间较长，我们选择直接进行真分数的操作。在java语言中并没有一个专门的类用来表示分数，所以需要手动添加。我们设计了一个专门的类用来描述分数（程序中的Fraction类），并且严格依照分数的性质来进行设计（例如分母不可以为0），其次我们要给出分数四则运算的计算方法。然后我们考虑的是，进行四则运算，要随机生成题目，我们选择分别建两个类，一个用来生成操作数（分数随机生成两个数字，分别做分子和分母），一个用来生成符号，生成的随机性我们通过random（）来保证。写好了这两个类之后，我们用另一个专门生成题目的类来调用这两个类中的方法组成题目。转后缀码后进行计算。最后统计结果。

三、实现过程中的关键代码解释：

实现分数代码：

public class Fraction {

    private long Numerator; // 分子
    private long Denominator; // 分母

    public Fraction(long Numerator, long Denominator) {
        this.Numerator = Numerator;     //将传过来的参数Numerator赋值给类中的Numerator
        if (Denominator == 0) {
            throw new ArithmeticException("分母不能为零");     //如果分母为0，抛出问题“分母不能为零”
        } else {
            this.Denominator = Denominator;       //如果分母不为0，将传过来的参数Denominator赋值给类中的Denominator
        }
        change();   //对分数进行化简
    }

    public Fraction() {              //将分数初始化
        this(0, 1);
    }
    public long getNumerator() {     //返回分子Numerator
        return Numerator;
    }
    public void setNumerator(long numerator) {
        Numerator = numerator;       //设置分子，将传过来的参数numerator赋值给类中的Numerator
    }
    public long getDenominator() {
        return Denominator;       //返回分母Denominator
    }
    public void setDenominator(long denominator) {
        Denominator = denominator;       //设置分母，将传过来的参数denominator赋值给类中的Denominator
    }
    private Fraction change() {
        long gcd = gcd(Numerator,Denominator);    //求分子和分母的最大公因子并将公因子的值赋给gcd
        Numerator /= gcd;           //将分子Numerator的值除以gcd的值赋给Numerator
        Denominator /= gcd;           //将分母Denominator的值除以gcd的值赋给Denominator
        return this;
    }
    private long gcd(long a, long b) {    //求a和b的最大公因数
        long mod = a % b;
        if (mod == 0) {
            return b;          //如果余数mod为0，返回除数即为最大公因数
        } else {
            return gcd(b, mod);   //如果余数mod不等于0，将除数b看做被除数，把余数看做除数递归调用gdc（b，mod）
        }
    }
    public Fraction add(Fraction second) {       //一个分数加一个分数的加法法则
        return new Fraction(this.Numerator * second.Denominator + second.Numerator * this.Denominator,
                this.Denominator * second.Denominator);
    }

    public Fraction minus(Fraction second) {      //一个分数减一个分数的减法法则
        return new Fraction(this.Numerator * second.Denominator - second.Numerator * this.Denominator,
                this.Denominator * second.Denominator);
    }

    public Fraction multiply(Fraction second) {          //一个分数乘一个分数的乘法法则
        return new Fraction(this.Numerator*second.Numerator,
                this.Denominator * second.Denominator);
    }

    public Fraction divide(Fraction second) {       //一个分数除以一个分数的除法法则
        return new Fraction(this.Numerator*second.Denominator,
                this.Denominator * second.Numerator);
    }

    public String toString() {     //讲分数以字符串的形式返回
        if(this.Denominator==1){
            return String.format("%d",this.Numerator);     //如果分母为1，输出分子
        }
        else {
            return String.format("%d/%d", this.Numerator, this.Denominator);     //如果分母不为1，输出"分子/分母"
        }
    }

}

生成问题代码：

import java.util.*;

public class CreateQuestion{
    public static String getQuestion(){       //得到一个String类型的问题
        CreateNumber getnum = new CreateNumber();   //新建一个CreateNumber类的对象getnum
        CreateOperator getope = new CreateOperator();     //新建一个CreateOperator类的对象getope
        Random r1 = new Random();
        String s = new String();
        int i,a1,a2,a3;
        a1 = r1.nextInt(4);  //随机生成一个[0,4)的数a1，这决定了公式的长度
        String question,qt;
        question=getnum.getNumber() + getope.getOperator();   //初始化变量question
        for(int j=1;j<=a1;j++){
            qt=getnum.getNumber()+getope.getOperator();
            question=question+qt;    //循环增加问题长度
        }
        question= question+getnum.getNumber();   //给问题的最后加上一个数
        char[] q = question.toCharArray();     //将生成的字符串变成字符数组，以便在里边加括号
        if(q.length>9){           // 字符串的长度在9以上才会进行加括号操作，避免出现因找不到加括号的位置而出现死循环的情况
            for(i=0;;i++){              //通过循环找寻适合加左括号的位置
                a2=r1.nextInt(q.length-3);     //随机生成一个位置的下标，在排除最后3个字符的字符串里找位置生成左括号，以便留给右括号空间
                if(a2<=5){
                    if(q[a2]=='+' || q[a2]=='-' || q[a2]=='*' || q[a2]=='÷'){
                        break;       //若找到合适位置便退出循环
                    }
                    else continue;    //未找到则继续循环
                }
            }
            char[] z1=addElementToArray1(q,a2);  //调用方法，把字符数组q[]，位置a2传到方法里边
            for(i=0;;i++){           //通过循环找寻适合加右括号的位置
                a3=r1.nextInt(z1.length);    //随机生成一个位置的下标，找位置生成右括号
                if(a3>a2+4){     //右括号的位置应该比左括号的位置靠右至少4位
                    if( z1[a3]=='+' || z1[a3]=='-' || z1[a3]=='*' || z1[a3]=='÷' || a3==q.length){
                        break;     //若找到合适位置便退出循环
                    }
                    else continue;     //未找到则继续循环
                }
            }
            char[] z2=addElementToArray2(q,z1,a3);    //调用方法，把字符数组q[]，z1[]，位置a2传到方法里边
            s = new String(z2);
            return s;
        }
        else s = new String(q);
        return s;

    }



    public static char[] addElementToArray1(char[] q,int a2) {
        char [] z1 = new char[q.length+1];     //字符数组z1长度相比q加一
        int i;
        for(i=z1.length-1;i>a2;i--){
            z1[i]=q[i-1];
        }
        z1[a2+1]='(';
        for(i=0;i<=a2;i++){
            z1[i]=q[i];
        }     //在q[]中a2位置加入左括号，写入z1[]

        return z1;
    }

    public static char[] addElementToArray2(char[] q,char[] z1,int a3) {
        char [] z2 = new char[z1.length+1];   //字符数组z2长度相比z1加一
        int i;
        if(z1[a3]=='+' || z1[a3]=='-' || z1[a3]=='*' || z1[a3]=='÷'){
            for(i=z2.length-1;i>a3;i--){
                z2[i]=z1[i-1];
            }
            z2[a3]=')';
            for(i=0;i<=a3-1;i++){
                z2[i]=z1[i];
            }
        }  //若a3位置为一个运算符，在z1[]中a3位置加入左括号，写入z2[]
        else {
            for(i=0;i<z1.length;i++){
                z2[i]=z1[i];
            }
            z2[z1.length]=')';
        }   //若a3等于字符数组q的长度，将z1写入z2，并在z2末尾加上右括号
        return z2;
    }
}

将生成的问题转为后缀表达式代码：

import java.util.*;
public class ChangeSuffix {
    String questions;
    String after_questions= "";
    public String toSuffix(String questions){
        this.questions=questions;
        Stack stack=new Stack();     //新建一个栈
        for (int i=0;i<questions.length();i++) {
            char ele=questions.charAt(i);   //取出字符串的第i个字符
            if (ele>='0'&&ele<='9'){
                after_questions=after_questions+ele;   //如果第i个字符为数字，直接写入到后缀表达式中
            }
            else if (ele=='+'||ele=='-'||ele=='*'||ele=='÷'||ele=='/') {
                after_questions=after_questions+" ";       //如果遇到运算符
                if (stack.empty()){
                    stack.push(ele);
                }      //若栈为空，字符进栈
                else if (priority(ele)>priority((char)stack.peek())) {
                    stack.push(ele);
                }       //如果栈顶元素的运算优先级小于当前字符的运算优先级，当前元素进栈
                else{
                    after_questions=after_questions+ String.valueOf(stack.pop())+" ";
                    i--;
                }     //其他情况即如果栈顶元素的运算优先级大于或等于当前字符的运算优先级，将该元素出栈，变成字符串类型
            }
            else if(ele=='('){
                stack.push(ele);
            }     //如果当前元素为左括号，进栈
            else if(ele==')'){
                after_questions+=" ";
                while((char)stack.peek()!='('){
                    after_questions=after_questions+ String.valueOf(stack.pop())+" ";
                }    //如果栈顶元素不是左括号，连续将栈顶元素弹出变成字符串类型写入到后缀表达式中
                stack.pop();  //将左括号弹出
            }
        }
        after_questions+=" ";
        while(!stack.empty()){
            after_questions=after_questions+String.valueOf(stack.pop())+" ";
        }    //如果栈顶元素非空，连续弹出栈顶元素变成字符串类型写入到后缀表达式中
        return after_questions;
    }
    public int priority (char c){       //定义运算符的优先级
        int pt =0;
        switch(c){
            case '(':
                pt=1;
                break;
            case '+':
            case '-':
                pt=2;
                break;
            case '*':
            case '÷':
                pt=3;
                break;
            case '/':
                pt=4;
                break;
            case ')':
                pt=5;
                break;
            default:
                pt=0;
                break;
        }
        return pt;
    }
}

计算后缀表达式代码：

import java.util.*;
public class Calculation {
    /** constant for addition symbol */
    private final char ADD = '+';
    /** constant for subtraction symbol */
    private final char SUBTRACT = '-';
    /** constant for multiplication symbol */
    private final char MULTIPLY = '*';
    /** constant for division symbol */
    private final char DIVIDE = '÷';
    private final char SEMICON= '/';
    /** the stack */
    private Stack<String > stack;

    public Calculation() {
        stack = new Stack<String>();    //创建一个String类型的栈
    }

    public String evaluate (String expr)
    {
        String op1,op2;
        Fraction p1;
        Fraction p2;
        String token;
        String result ="";
        StringTokenizer tokenizer = new StringTokenizer (expr);  //将expr后缀表达式传进StringTokenizer方法

        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();    //将StringTokenizer分解出的字符串赋给token

            //如果是运算符，调用isOperator
            if (isOperator(token))
            {
                //从栈中弹出操作数2
                op2=stack.pop();
                p2 = toFraction(op2);
                //从栈中弹出操作数1
                op1=stack.pop();
                p1 =toFraction(op1);
                //根据运算符和两个操作数调用evalSingleOp计算result;
                result=evalSingleOp(token.toCharArray()[0],p1,p2);
                //计算result入栈;
                stack.push(result);
            }
            else//如果是操作数，入栈
                stack.push(token);
        }

        return result;
    }

    private boolean isOperator (String token)
    {
        return ( token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("÷")||token.equals("/") );    //若token是运算符，返回true
    }

    private String evalSingleOp (char operation, Fraction p1, Fraction p2)
    {
        Fraction result = new Fraction(0,1);     //初始化result

        switch (operation)    //根据运算符选择运算
        {
            case ADD:
                result =p1.add(p2);
                break;
            case SUBTRACT:
                result = p1.minus(p2);
                break;
            case MULTIPLY:
                result = p1.multiply(p2);
                break;
            case DIVIDE:
            case SEMICON:
                result = p1.divide(p2);
        }

        return result.toString();     //将结果变成字符串
    }
    private Fraction toFraction(String m){
        String token1, token2;
        Fraction r = new Fraction(0,1);
        StringTokenizer tokenizer1 = new StringTokenizer(m, "/");//把操作数以"/"为标记分割开来
        token1 = tokenizer1.nextToken();
        if (tokenizer1.hasMoreTokens()) {//如果有第二个元素就把token1放在分子的位置，token2放在分母的位置
            token2 = tokenizer1.nextToken();
            int toke1 =Integer.valueOf(token1).intValue();
            int toke2 =Integer.valueOf(token2).intValue();
            r =new Fraction(toke1,toke2);
        }
        else {//如果没有第二个元素就把token1放在分子的位置，分母固定为1
            int toke1 = Integer.valueOf(token1).intValue();
            r =new Fraction(toke1,1);
        }
        return r;

    }
}

 

四、测试方法

1.Fraction类分数类的测试：

2.ChangeSuffix类将问题转为后缀表达式类的测试

3.Calculation类计算类的测试

五、运行结果截图

六、代码托管

七、遇到的问题及解决办法

问题1：分数有一个很重要的特点，就是他的分母不可以为0。编写分数时，不知道如果生成了这种情况该怎么处理，就强行将分母为0的时候给分母强行改成其他值，虽然写法在理论上应该是没毛病的，可是他就是运行不出结果，程序就不往下运行了。

问题1解决办法：网上搜可以用ArithmeticException方法将此问题抛出并退出程序，就不会出现程序既不退出也无法继续运行的情况了。现在想想，可以将随机生成的分母加1，这样就不会出现分母为0的情况了。

问题2：在生成的无括号的题目里面加括号，如果生成的算式很短，且第一个括号加的靠后，那么第二个括号可能会找不到位置，或者括号只能括起来一个数。

问题2解决办法：如果算式特别短，将不生成括号，只有在字符串长度大于9才会进行生成括号的操作，这样虽然不能给一些数小的但能加括号算式加括号，但问题能避免了。

问题3：本来生成的无括号的题目是一个字符串，在里面我能找元素，但是我不会在里面加元素。

问题3解决办法：网上说，可以用toCharArray方法把字符串化成字符数组，然后进行操作，操作完以后再把它转化成字符串。

问题4：对后缀表达式进行计算时，看了栈的基本操作，仿照老师的后缀表达式计算代码将分数的计算也加进去。使用过程中发现Stack中的E为栈储存的数据形式，如果数据形式不一致将无法储存

问题4解决办法：将栈改为存储string类型。还有一个改动是要将其中的“/”和“÷”进行区分，“/”专指分号，优先度要高于乘除符号，但算法可以与除号等同。

八、对结对的小伙伴做出评价

这两天确实是非常感谢他的付出、陪伴与理解。我们这个结对项目，按老师的要求就是一个驾驶员，一个领航员。这确实是一种非常好的合作方式，可是，在做Java的同时，要学其他科目，要做好自己的学生工作等等，这导致我们并没有太多时间在一起写同一个代码，更多的是我们分好工，你把你的做好，我把我的做好，如果有问题一起想想，两个人一起解决一下。也许是我们对老师所说的一个驾驶员一个领航员的合作方式还不适应，所以不能在以其高效率的写代码，以后会继续向这方面努力。我们合作期间，我可能要做的其他的事多一下，做事也磨蹭一点，将代码写出来总是慢他三分，所以他付出的会更多一些，感谢他的付出；因为我做的慢，他偶尔也会埋怨我一下，但过两分钟，就又来给我加油了，真也非常感谢他的陪伴与理解。下次我会尽量的加快我的脚步，做事效率高一点，不能让你做那么多，我也要为咱们俩的项目付出更多！

九、PSP图：

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