20172325『Java程序设计』课程 结对编程练习_四则运算第二周阶段总结

20172325『Java程序设计』课程 结对编程练习_四则运算第二周阶段总结

结对伙伴

• 学号：20172306
• 姓名：刘辰
• 结对伙伴博客链接
• 刘辰同学对编程的积极程度很高，并且在编程能力上很不错，有自己的想法并且能够把这个想法具体的实践出来，只是在编程的过程中和同学交流不够，总是在最后不行了才发现问题，很容易造成前功尽弃，希望在编程过程中多沟通，减少不必要的时间精力的浪费。

小组结对编程照片

项目中自己负责的部分

我负责的是两个部分，分别是：

• 1、利用栈将中缀表达式转后缀表达式；
• 2、对后缀表达式进行计算。

个人贡献度划分

我认为我们的贡献度划分是“ 50% ：50% ” ；我们有两个成员，然后任务分配也比较容易，必做部分有四个，我们一人两个部分，因为每一个部分的完成都需要投入时间和精力，所以我认为没有难易之分，五五开。

相关过程的截图

- 分等级的题目的生成

- 能够实现真分数

- 后缀表达式的计算

关键代码解释

• 后缀表达式的计算

```package 结对项目;
/*

• 后缀表达式的计算 作者：邓煜坤，刘辰
• 邓煜坤负责的部分
  */

import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Scanner;

public class HZ {

/
由于我们的Test文件还没编好，各部分还没有联系起来，所以我先在这里把四个符号做出了声明
*/

private final char ADD = '+';
private final char SUBTRACT = '-';
private final char MULTIPLY = '*';
private final char DIVIDE = '/';

private Stack<Integer> stack;

/*
 * 初始化一个空栈，用来存储表达式
 */
public HZ (){
    stack = new Stack<Integer>();
}

/*
 * 此处用来判断指定的char是否为操作符。
 *  如果是运算符，布尔值为真
 */
private boolean isOperator(String str) {

    return (str.equals("+") || str.equals("-") || str.equals("*") || str
            .equals("/"));
}

/*
 * 下面是具体的计算过程
 */
private int calculateSingleOp(char operator, int num1, int num2) {

    int result = 0;
    switch (operator)
    {
        case ADD:
            result = num1 + num2;
            break;
        case SUBTRACT:
            result = num1 - num2;
            break;
        case MULTIPLY:
            result = num1 * num2;
            break;
        case DIVIDE:
            result = num1 / num2;
            break;
    }

    return result;
}

/*
 *下面是计算指定的后缀表达式。
 *(1).如果遇到操作数，将其推送到栈上。
 *(2).如果遇到操作符，则弹出两个操作数以供运算符计算。
 *(3).将计算结果推到栈上。
 *字符串表示后缀表达式。
 */
public int evaluate (String str) {

    int num1, num2, result = 0;
    // 指定特定的字符分隔符为空格。
    String token = "";
    StringTokenizer tokenizer = new StringTokenizer(str);

    while (tokenizer.hasMoreTokens()) {
        // 每一个字符都来自于字符串。
        token = tokenizer.nextToken();

        if (isOperator(token)) {
            num2 = (stack.pop()).intValue();
            num1 = (stack.pop()).intValue();
            result = calculateSingleOp(token.charAt(0), num1, num2);
            // 将计算结果推到栈上
            stack.push(new Integer(result));
        } else {
            stack.push(new Integer(Integer.parseInt(token)));
        }
    }
    return result;
}


public static void main(String[] args) {
    String expression = "";
    String again = "";
    int result = 0;

    try {
        @SuppressWarnings("resource")
        Scanner input = new Scanner(System.in);
        do {
            HZ evaluator = new HZ();
            // 读取一个有效的后缀表达式。即用户输入有效后缀表达式，之后在Test文件里将参数构建过来就好了。
            System.out
                    .println("Please enter a valid postfix expression : ");
            
            expression = input.nextLine();

            result = evaluator.evaluate(expression);
            System.out.println();
            System.out
                    .println("After evaluating, the calculated result is : "
                            + result);

            // 重复操作
            System.out.println("Do you want to test again? [Y/N]");
            again = input.nextLine();
            System.out.println();
        } while (again.equalsIgnoreCase("Y"));
    } catch (Exception IOException) {
        System.out.println("Input exception reported.");
    }
}

```}