结对编程(JAVA实现)

一、github地址:https://github.com/Jasminejiamei/pairProgramming

二、PSP表格

PSP Personal Software Process Stages 预估耗时(分钟) 实际耗时(分钟)
Planning 计划  60 40
· Estimate · 估计这个任务需要多少时间   60  40
Development 开发 1440 1505
· Analysis · 需求分析  30  15
· Design Spec · 生成设计文档  20  15
· Design Review · 设计复审   30  15
· Coding Standard · 代码规范  20  20
· Design · 具体设计  80  80
· Coding · 具体编码  900  980
· Code Review · 代码复审  30  30
· Test · 测试(自我测试,修改代码,提交修改)  330  400
Reporting 报告 130 100
· Test Report · 测试报告  80  60
· Size Measurement · 计算工作量  30  20
· Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划  30  20
  合计  1630   1695

三、效能分析

  由于之前采用单线程执行,在文件IO流的处理上花费了不少的时间,包括代码上的执行存在部分冗余,代码上可以提高利用率。打开了线程池以后,多线程执行,大大提高了执行速度,在代码逻辑改进优化后,对大量生成题目的效果十分显著,由30s时间完成优化到2s: 

结对编程(JAVA实现)

结对编程(JAVA实现)

 

四、设计过程

(一)流程图

视图设计过程:

结对编程(JAVA实现)

生成题目设计过程:

结对编程(JAVA实现)

判断对错设计过程:

结对编程(JAVA实现)

(二)项目目录:

结对编程(JAVA实现)

分包思路:

1)视图层:view 包含主页面与两个功能页面

2)实体类:po  包含题目存放类Deposit、ChildDeposit,分数处理类

3)逻辑处理层:service  处理题目生成等的逻辑、处理题目判错的逻辑

4)工具类:util 包含文件的读写功能

 

(三)总体实现思路

  程序运行,进入主页面,点击选择进入相应功能页面(生成题目or判断对错),如果为生成题目,用户需要输入相关参数(题目数量、数的大小范围),视图层获取输入的数据,传入至逻辑层中进行处理,先判断输入是否有误,有误则终止程序,无误则调用题目生成的方法CreateAth;如果为判断对错,用户需要选择相应的文件(Exersises.txt和Answers.txt),视图层获取输入的数据,传入到逻辑层进行处理,判断输入无误后,调用题目盘错的方法Judge。

  题目生成的思路:题目要求生成的算术运算符少于3个,先随机生成一个运算符的个数,传入到CreateAth方法中,先生成一个根结点即算术运算符,然后随机生成在左右子树小于总运算符个数的运算符个数,同时生成运算符,当生成运算符个数为0,则生成叶子结点即运算操作数,左右子树也是重复上述过程。把生成的算式放在一个动态数组里面,每当生成一个算式,就去检查里面是否包含这个算式,如果重复就去掉,达到查重的目的。

  判断对错的思路:使用readfile读取Exersises.txt文件内容,使用正则表达式分割开题目的序号和算式,算式是中缀表达式的表示方式,通过build方法把算式改为前缀表达式,如:1 + (( 2 + 3)* 4 ) – 5,转换成前缀则为- + 1 * + 2 3 4 5,计算其答案,读取Answers.txt的内容,使用正则表达式分割开题目的序号和答案,根据两个文件的序号,对比答案是否相同,如果相同则记录对的题目的数量,和题目序号,写出到Correction.txt文件。

 

(四)细节实现思路

1)如何保证基本的数值运算,确定参数的范围?

  自然数的数值之间的运算可简单实现,但是自然数、真分数、带分数之间的运算之间的格式需要自己设计的,并且题目要求“如果存在形如e1÷ e2的子表达式,那么其结果应是真分数”,经过讨论之后,决定把所有数据统一当成分数来处理,整数的分母则为1,在运算的过程中把分子与分母独立出来分别操作加减乘除运算,到最后再进行约分等化简处理。

2)怎么生成算式并且查重?

  生成的算式要求不能产生负数、生成的题目不能重复,且即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目,经过讨论,决定使用二叉树来实现,由于二叉树的运算次序是孩子结点的运算次序要优先于根结点的,所以使用非叶子节点存放运算符,叶子结点存放数值,可以解决前后符号之间的优先级别关系,解决括号的添加问题,当父母结点的算术符优先级高于右孩子结点的算术运算符时,左右都要加括号,当相等时,则右孩子树要加括号;出现了负数时,交换左右子树即可;此外,解决了查重的复杂度问题,开始的方案想采用遍历的方式来达到查重,现只需要判断两棵树是否相同即可。

 

五、程序关键代码

从页面获取到数据,进行处理:

结对编程(JAVA实现)
package service;

import java.util.HashMap;
import java.util.Map;

public class EntryJudge{
    public boolean Entry(String[] args){
        //向主页面返回的运行成功与否的标志
        boolean tag = false;
        //判断用户输入是否正确
        if(args.length == 0 || args.length % 2 != 0)  {
            tag = false;
            return tag;
        }
        //取出参数
        Map<String, String> params = checkParams(args);
        //执行相应处理
        CreateAth opera = new CreateAth(params);
        Judge check =  new Judge(params);
        if(params.containsKey("-e")&&params.containsKey("-a")){
            check.Judge();
            tag = true;
            return tag;
        } else if(params.containsKey("-n") || params.containsKey("-r") || params.containsKey("-d")) {
            opera.createAth();
            tag = true;
            return tag;
        }
        return tag;
    }
    private Map<String, String> checkParams(String[] args) {
        Map<String, String> params = new HashMap<>();
        for (int i = 0; i < args.length; i = i + 2) {
            params.put(args[i], args[i+1]);
        }
        return params;
    }
}
EntryJudge

 

题目生成逻辑处理:

结对编程(JAVA实现)CreateAth

 

题目判错处理:判断答案的正确性,并记录下来正确题目与错误题目序号,打印到Grade.txt

结对编程(JAVA实现)
package service;

import po.Fraction;
import util.FileUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 答案判错类
 */
public class Judge{
    private int trueNum;  //正确数目
    private int wrongNum;    //错误数目
    private String exerciseFileName;  // 题目文件名
    private String answerFileName;  // 答案文件名

    public Judge(Map<String, String> params) {
        for (String str : params.keySet()) {
            if (str.equals("-e")) {
                exerciseFileName = params.get(str);
            } else if (str.equals("-a")) {
                answerFileName = params.get(str);
            }
        }
    }
    /**
     * 判断错误 ,并把错误写入文件
     */
    public void Judge() {
        long start = System.currentTimeMillis();
        List<String> correctNums = new ArrayList<>();
        List<String> wrongNums = new ArrayList<>();
        FileUtil.readFile((exercise, answer) -> {
            String[] strs1 = exercise.split("\\."); //匹配每一行
            String[] strs2 = answer.split("\\.");
            if (strs1[0].equals(strs2[0])) {
                CreateAth exes = new CreateAth(false);
                exes.build(strs1[1].trim());  //去掉两端的空格后,将后缀表达式生成树变成前缀的,
                if (exes.getResult().equals(new Fraction(strs2[1].trim()))) {   //答案两边都相等,继续执行下面的
                    correctNums.add(strs1[0]);
                    trueNum++;
                } else {
                    wrongNums.add(strs1[0]);
                    wrongNum++;
                }
            }
        }, exerciseFileName, answerFileName);
        FileUtil.writeFile(printResult(correctNums, wrongNums), "Correction.txt");
        long end = System.currentTimeMillis();
        System.out.println("题目答案对错统计存在当前目录下的Correction.txt文件下,耗时为:" + (end - start) + "ms");
    }

    private String printResult(List<String> correctNums, List<String> wrongNums) {
        StringBuilder builder = new StringBuilder();
        builder.append("Correct: ").append(trueNum).append(" (");
        for (int i = 0; i < correctNums.size(); i++) {
            if (i == correctNums.size() - 1) {
                builder.append(correctNums.get(i));
                break;
            }
            builder.append(correctNums.get(i)).append(", ");
        }
        builder.append(")").append("\n");
        builder.append("Wrong: ").append(wrongNum).append(" (");
        for (int i = 0; i < wrongNums.size(); i++) {
            if (i == wrongNums.size() - 1) {
                builder.append(wrongNums.get(i));
                break;
            }
            builder.append(wrongNums.get(i)).append(", ");
        }
        builder.append(")").append("\n");
        return builder.toString();
    }
}
Judge

 

分数处理类:把所有随机生成的数都当成是分数处理,同时在些定义分数的四则运算方法

结对编程(JAVA实现)
package po;

/**
 * 1. 把所有随机生成的数都当成是分数处理(解决了自然整数,分数,带分数之间的差异)
 * 2. 定义了分数的四则运算类
 */
public class Fraction{

    private int mol; //分子
    private int den;  //分母

    /**
     * 处理随机生成的数值(约分等),组合分数对象
     */
    public Fraction(int mol, int den) {
        this.mol = mol;
        this.den = den;
        if (den <= 0) {
            throw new RuntimeException("分数分母不能为0");
        }
        //否则就进行约分
        int mod = 1;
        int max = den > mol ? den : mol;
        for (int i = 1; i <= max; i++) {
            if (mol % i == 0 && den % i == 0) {
                mod = i;
            }
        }
        this.mol = mol / mod;
        this.den = den / mod;
    }

    /**
     * 处理随机生成的数值,这个用于分解分数对象(仅在判错中使用)
     */
    public Fraction(String str) {
        int a = str.indexOf("'");
        int b = str.indexOf("/");
        if (a != -1) {
            //取出数组,转换类型
            int c = Integer.valueOf(str.substring(0, a));
            den = Integer.valueOf(str.substring(b + 1));
            mol = c * den + Integer.valueOf(str.substring(a + 1, b));
        } else if (b != -1) {
            String[] sirs = str.split("/");
            mol = Integer.valueOf(sirs[0]);
            den = Integer.valueOf(sirs[1]);
        } else {
            mol = Integer.valueOf(str);
            den = 1;
        }
    }/**
     * 定义加减乘除类,返回值类型(全都当成分数处理),由于要返回这个类的内容,所以方法前要加类名
     */
    public Fraction add(Fraction fraction) {
        return new Fraction(this.mol * fraction.den + this.den * fraction.mol, this.den * fraction.den);
    }

    public Fraction subtract(Fraction fraction) {
        return new Fraction(this.mol * fraction.den - this.den * fraction.mol, this.den * fraction.den);
    }

    public Fraction multiply(Fraction fraction) {
        return new Fraction(this.mol * fraction.mol, this.den * fraction.den);
    }

    public Fraction divide(Fraction fraction) {
        return new Fraction(this.mol * fraction.den, this.den * fraction.mol);
    }

}
Fraction

 

题目实现存放类以及其子类:

结对编程(JAVA实现)
package po;

import java.util.Objects;
/**
 * 用于存放题目的类,用二叉树的形式
 */
public class Deposit{

    private Deposit left;
    private Deposit right;
    private Fraction value; //用于二叉树结点的是符号与运算结果数值的之间的变化

    public Deposit(Fraction value, Deposit left, Deposit right){
        this.value = value;
        this.left = left;
        this.right = right;
    }

    /**
     * 取结点数据
     */
    public Fraction getValue() {
        return value;
    }
    public Deposit getRight(){
        return right;
    }
    public Deposit getLeft(){
        return left;
    }

    /**
     * 设置结点数据
     */
    public Deposit(Fraction value){
        this.value = value;
    }
    public void setLeft(Deposit left){
        this.left = left;
    }
    public void setRight(Deposit right){
        this.right = right ;
    }
    public void setValue(Fraction value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value.toString();
    }

    /**
     * 用于查重,判断二棵树是否相同
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Deposit)) return false;
        Deposit node = (Deposit) o;
        return Objects.equals(value, node.value) &&
                Objects.equals(left, node.left) &&
                Objects.equals(right, node.right);
    }
}

—————————————————————————————————————分割线——————————————————————————————————————————————

package po;

/**
 * 用于记录符号结点,与Deposit类是一样的道理
 */
public class ChildDeposit extends Deposit{

    private String symbol;

    public ChildDeposit(String symbol, Deposit left, Deposit right){
        super(null, left, right);
        this.symbol = symbol;
    }

    public String getSymbol() {
        return symbol;
    }

    @Override
    public String toString() {
        return " " + symbol + " ";
    }

    /**
     * 用于查重
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ChildDeposit)) return false;
        ChildDeposit that = (ChildDeposit) o;

        boolean flag = this.symbol != null && symbol.equals(that.symbol);
        if(!flag) return false;

        boolean left = this.getLeft() != null && getLeft().equals(that.getLeft());
        boolean right = this.getRight() != null && getRight().equals(that.getRight());
        //左右子树相同
        if(left && right) {
            return true;
        }
        if(left ^ right) {
            return false;
        }
        //如果是加法或乘法由于满足交换律所以要判断
        if(this.symbol.equals("+") || this.symbol.equals("x")) {
            left = this.getLeft() != null && getLeft().equals(that.getRight());
            right = this.getRight() != null && getRight().equals(that.getLeft());
        }
        return left && right;
    }
}
Deposit,ChildDeposit

 

文件读写工具类:处理文件的写入与读出

结对编程(JAVA实现)
package util;

import java.io.*;

public class FileUtil{
    /**
     * 写入文件中
     */
    public static void writeFile(String content, String fileName) {
        File file = new File(fileName);
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))){
            if(!file.exists()){
                file.createNewFile();
            }
            bw.write(content);
            bw.flush();
        } catch (IOException e) {
            System.out.println("文件操作失败...");
        }
    }
    /**
     * 读文件内容
     * @param callBack 回调接口,分别处理每一行
     * @param exerciseFileName 题目文件
     * @param answerFileName 答案文件
     */
    public static void readFile(ReaderCallBack callBack, String exerciseFileName, String answerFileName) {
        File exerciseFile = new File(exerciseFileName);
        File answerFile = new File(answerFileName);
        if(!exerciseFile.exists() || !answerFile.exists()) {
            System.out.println("文件不存在!");
            return;
        }
        try (BufferedReader br1 = new BufferedReader(new FileReader(exerciseFileName));
             BufferedReader br2 = new BufferedReader(new FileReader(answerFileName))) {
            String line1, line2;
            while ((line1 = br1.readLine()) != null && (line2 = br2.readLine()) != null) {
                callBack.deal(line1, line2);
            }
        } catch (IOException e) {
            System.out.println("读取文件失败!");
        }
    }

    public interface ReaderCallBack {
        void deal(String exercise, String answer) throws IOException;
    }
}
FileUtil

 

图形界面:

MainView :主页面,用户在两种操作中选一进行

结对编程(JAVA实现)
package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MainView {
    public static void main(String[] args) {
        new MainJFrame();
    }
}
class MainJFrame extends JFrame {
    /**
     *   程序主界面
     */
    private static final long serialVersionUID = 1;
    //定义全局变量

    private JLabel title;
    private JButton generate,judge;

    private JLabel result;
    private JPanel down = new JPanel();

    //创建一个容器
    Container ct;

    MainJFrame(){

        ct=this.getContentPane();
        this.setLayout(null);//设置容器为空布局,绝对定位

        //标题
        title= new JLabel("四则运算题目生成程序");
        title.setFont(new Font("微软雅黑",Font.BOLD, 30));
        title.setBounds(140, 40, 340, 100);

        //生成
        generate = new JButton("生成题目");
        generate.setBounds(120, 220, 140, 40);
        generate.addActionListener(new generateListener());
        //判错
        judge = new JButton("判断对错");
        judge.setBounds(300, 220, 140, 40);
        judge.addActionListener(new judgeListenner());
//添加组件

        ct.add(title);
        ct.add(generate);
        ct.add(judge);
        ct.add(down);
        this.setTitle("MyApp");
        this.setSize(600, 450);// 设置窗口大小
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setVisible(true);//显示窗口
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //关闭窗口 当点击窗口的关闭按钮时退出程序(没有这一句,程序不会退出)
    }


    class generateListener implements ActionListener {
        //监听生成按钮点击事件
        public void actionPerformed(ActionEvent e) {

            new GenerateView();
        }

    }
    class judgeListenner implements ActionListener{
        //监听判错按钮点击事件
        public void actionPerformed(ActionEvent e) {
            new JudgeView();

        }
    }
}
MainView

 

GenerateView:用户输入参数范围、生成题目的页面

结对编程(JAVA实现)
package view;

import service.EntryJudge;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GenerateView extends JFrame {


    private JLabel title,result;
    private JButton confirm;
    private JLabel subjectNum,intArea,denArea;
    private JTextField subjectNumField,intAreaField,denAreaField;
    private JPanel down = new JPanel();


    public GenerateView() {
        //创建一个容器
        Container ct;
        ct=this.getContentPane();
//        this.setLayout(null);//设置容器为空布局,绝对定位

        this.setSize(600, 450);//基本设置
        this.setLocationRelativeTo(null);
        this.setLayout(null);
        title = new JLabel("生成题目");
        title.setFont(new Font("微软雅黑",Font.BOLD, 20));
        title.setBounds(200,20,280,60);
        //生成题目数
        subjectNum = new JLabel("请输入生成题目数:");
        subjectNum.setFont(new Font("微软雅黑",Font.BOLD, 16));
        subjectNum.setBounds(70,100,160,50);
        subjectNumField = new JTextField (10);
        subjectNumField.setBounds(260,100,260,40);
        //整数范围
        intArea = new JLabel("请输入整数范围:");
        intArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        intArea.setBounds(70,150,160,50);
        intAreaField = new JTextField (20);
        intAreaField.setBounds(260,150,260,40);
        //分母范围
        denArea = new JLabel("请输入分数分母的范围:");
        denArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        denArea.setBounds(70,200,180,50);
        denAreaField = new JTextField (20);
        denAreaField.setBounds(260,200,260,40);
        confirm = new JButton("确定");
        confirm.setBounds(250,270, 60, 50);
        confirm.addActionListener(new ConfirmActionListener());
        //设置底部panel
        down.setBounds(130, 330, 280, 50);
        //设置底部panel背景透明
        down.setBackground(null);
        down.setOpaque(false);
        result= new JLabel();
        result.setFont(new Font("微软雅黑",Font.BOLD, 18));
        //添加组件
        down.add(result);
        ct.add(title);
        ct.add(subjectNum);
        ct.add(subjectNumField);
        ct.add(intArea);
        ct.add(intAreaField);
        ct.add(denArea);
        ct.add(denAreaField);
        ct.add(confirm);
        ct.add(down);

        this.setVisible(true);//显示窗口
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  //关闭窗口
    }
    class ConfirmActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            String args1 = subjectNumField.getText();
            String args2 = intAreaField.getText();
            String args3 = denAreaField.getText();

            String [] args  = new String[]{"-n",args1,"-r",args2,"-d",args3};
            EntryJudge ej = new EntryJudge();
            boolean res = ej.Entry(args);
            //获取命令执行结果
            if(res == true) {
                result.setText("结果:生成题目成功" );

            } else{
                result.setText("结果:生成题目失败" );

            }
        }
    }
}
GenerateView

 

JudegeView:用户选择文件,是判断对错的页面

结对编程(JAVA实现)
package view;

import service.EntryJudge;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class JudgeView extends JFrame {


    private JLabel title,result;
    private JButton confirm;
    private JLabel subjectNum,intArea,file1,file2;
    private JButton btn1,btn2;
    private JPanel down = new JPanel();


    public JudgeView() {
        //创建一个容器
        Container ct;
        ct=this.getContentPane();

        this.setSize(600, 450);//基本设置
        this.setLocationRelativeTo(null);
        this.setLayout(null);
        title = new JLabel("判断对错");
        title.setFont(new Font("微软雅黑",Font.BOLD, 20));
        title.setBounds(200,20,280,60);
        //生成题目数
        subjectNum = new JLabel("请选择题目文件:");
        subjectNum.setFont(new Font("微软雅黑",Font.BOLD, 16));
        subjectNum.setBounds(70,100,160,50);
        btn1 = new JButton ("选择文件");
        btn1.setBounds(240,100,120,40);
        btn1.addActionListener(new ChooseFile1ActionListener());
        file1 = new JLabel();
        file1.setFont(new Font("微软雅黑",Font.BOLD, 14));
        file1.setBounds(390,100,130,50);
        //整数范围
        intArea = new JLabel("请输入答案文件:");
        intArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        intArea.setBounds(70,150,160,50);
        btn2 = new JButton ("选择文件");
        btn2.setBounds(240,150,120,40);
        btn2.addActionListener(new ChooseFile2ActionListener());

        file2 = new JLabel();
        file2.setFont(new Font("微软雅黑",Font.BOLD, 14));
        file2.setBounds(390,150,130,50);

        confirm = new JButton("确定");
        confirm.setBounds(250,270, 60, 50);
        confirm.addActionListener(new ConfirmActionListener());
        //设置底部panel
        down.setBounds(130, 330, 280, 50);
        //设置底部panel背景透明
        down.setBackground(null);
        down.setOpaque(false);
        result= new JLabel();
        result.setFont(new Font("微软雅黑",Font.BOLD, 18));
        //添加组件
        down.add(result);
        ct.add(title);
        ct.add(subjectNum);
        ct.add(btn1);
        ct.add(file1);
        ct.add(intArea);
        ct.add(btn2);
        ct.add(file2);

        ct.add(confirm);
        ct.add(down);

        this.setVisible(true);//显示窗口
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  //关闭窗口
    }
    class ChooseFile1ActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            JFileChooser chooser = new JFileChooser();             //设置选择器
            chooser.setMultiSelectionEnabled(true);             //设为多选
            int returnVal = chooser.showDialog(new JLabel(),"选择");
            String filename = chooser.getSelectedFile().getName();      //获取绝对路径

            file1.setText(filename);

        }
    }
    class ChooseFile2ActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            JFileChooser chooser2 = new JFileChooser();             //设置选择器
            chooser2.setMultiSelectionEnabled(true);             //设为多选
            int returnVal = chooser2.showDialog(new JLabel(),"选择");

            String filename = chooser2.getSelectedFile().getName();      //获取绝对路径

            file2.setText(filename);
        }
    }
    class ConfirmActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {
            //获取结果
            String [] args = new String[]{"-e", "Exercises.txt","-a","Answers.txt"};
            EntryJudge ej = new EntryJudge();
            boolean res = ej.Entry(args);
            //获取命令执行结果
            if(res == true) {
                result.setText("结果:生成题目成功" );

            } else{
                result.setText("结果:生成题目失败" );

            }
        }
    }
}
JudegeView

 

六、测试测试结果

程序运行,成功打开图形界面:

结对编程(JAVA实现)

点击生成题目:

结对编程(JAVA实现)

测试题目生成是否成功:

输入相关参数,点击确定 ,生成题目成功:

结对编程(JAVA实现)

 查看Exersises.txt,成功生成题目:

 结对编程(JAVA实现)

 查看Answers.txt,答案:

结对编程(JAVA实现)

测试判错程序:

改错二道题的答案:

结对编程(JAVA实现)

打开判错的图形界面:

结对编程(JAVA实现)

选择算式文件:

结对编程(JAVA实现)

选择答案文件:

 结对编程(JAVA实现)

选择文件后:

结对编程(JAVA实现)

点击确定,查看统计文件Grade.txt:

结对编程(JAVA实现)

生成一万道算式:

详细的github地址:

算式生成文件:https://github.com/Jasminejiamei/pairProgramming/blob/master/Exercises.txt

答案生成文件:https://github.com/Jasminejiamei/pairProgramming/blob/master/Answers.txt

部分截图:

结对编程(JAVA实现)

结对编程(JAVA实现)

 

七、项目小结

      此次的结对编程,我们均涉及了代码的设计、编写以及测试。讨论项目的基本构思对我负责的前期编码十分重要,从基础数值的定义和生成,再到采用二叉树存放算式,最后一步步完成项目,通过两个人的讨论,使得项目的整体思路变得清晰。在后期的编码中我的伙伴对我的编程方式提出了更有条理性的建议,最终在小改动下让整个项目的代码变得更为整洁与条理。

     多讨论交流意见对编程的帮助很大,在判错功能中,从开始的没有头绪,到讨论出来通过应用一个栈的实例:中缀表达式转前缀表达式,解决了判错的问题;开始项目生成大数量题目的速度很慢,在小伙伴丰富的编程经验下,指出了关于多线程运行程序的方式,并且通过优化一些代码,大大提高了效率。

项目成员:黄思扬(3117004657)、刘嘉媚(3217004685)

 
上一篇:可视化医学图像CT


下一篇:P2347 砝码称重