结对编程（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;
    }
}

package service;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.StringStack;
import po.Deposit;
import po.Fraction;
import util.FileUtil;
import po.ChildDeposit;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

/**
 * 生成题目类
 */
public class CreateAth{
    private int maxNum = 100; //生成题目的整数最大值
    private int denArea = 20; //分母的范围
    private int maxCount = 10;//生成题目数量
    private Deposit content;
    private static final String[] SYMBOLS = new String[]{
            "+", "-", "x", "\u00F7"
    };

    /**
     * 生成随机题目，初始化，把主类中输入的参数内容调进来
     */
    public CreateAth(Map<String, String> params) {
        for (String str : params.keySet()) {
            if (str.equals("-n")) {
                maxCount = Integer.valueOf(params.get(str));
            } else if (str.equals("-r")) {
                maxNum = Integer.valueOf(params.get(str));
            } else if (str.equals("-d")) {
                denArea = Integer.valueOf(params.get(str));
            }
        }
    }

    /**
     * 生成题目
     */
    private ExecutorService executor = Executors.newCachedThreadPool();

    public void createAth() {
        StringBuilder exercises = new StringBuilder();
        StringBuilder answers = new StringBuilder();
        List<CreateAth> list = new ArrayList<>();
        long start = System.currentTimeMillis();
        for (int i = 1; i <= maxCount;) {
            CreateAth generate = new CreateAth(true);
            if (!list.contains(generate)){
                String[] strs = generate.print().split("=");
                exercises.append(i).append(". ").append(strs[0]).append("\n");
                answers.append(i).append(".").append(strs[1]).append("\n");
                list.add(generate);
                i++;
            }
        }
        executor.execute(() -> FileUtil.writeFile(exercises.toString(), "Exercises.txt"));
        executor.execute(() -> FileUtil.writeFile(answers.toString(), "Answers.txt"));
        executor.shutdown();
        long end = System.currentTimeMillis();
        try {
            boolean loop = true;
            while (loop) {
                loop = !executor.awaitTermination(30, TimeUnit.SECONDS);  //超时等待阻塞，直到线程池里所有任务结束
            } //等待所有任务完成
            System.out.println("生成的" + maxCount + "道题和答案存放在当前目录下的Exercises.txt和Answers.txt，耗时为："+(end - start) + "ms");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    ——————以下是生成题目所调用到的方法———————————
    /**
     * 生成组成题目随机数
     * area：分母的范围
     */
    private int random(int area) {
        ThreadLocalRandom random = ThreadLocalRandom.current();
        int x = random.nextInt(area);
        if (x == 0) x = 1;
        return x;
    }
    /**
     * ThreadLocalRandom类在多线程环境中生成随机数。
     * nextBoolean() 方法用于从随机数生成器的序列返回下一个伪随机的，均匀分布的布尔值
     */
    private boolean randomBoolean() {
        ThreadLocalRandom random = ThreadLocalRandom.current();
        return random.nextBoolean();
    }
    /**
     * 把生成的每个数进行处理得出分子分母
     */
    private Fraction creator() {
        if (randomBoolean()) {
            return new Fraction((random(maxNum)), 1);
        } else {
            if (randomBoolean()) {
                int den = random(denArea);
                int mol = random(den * maxNum);
                return new Fraction(den, mol);
            } else {
                int den = random(denArea);
                return new Fraction(random(den), den);
            }
        }
    }

    /**
     * 单步计算
     * @param symbol 符号
     * @param left  左
     * @param right 右
     * @return 得出来结果后经过约分的分数
     */
    private Fraction calculate(String symbol, Fraction left, Fraction right) {
        switch (symbol) {
            case "+":
                return left.add(right);
            case "-":
                return left.subtract(right);
            case "x":
                return left.multiply(right);
            default:
                return left.divide(right);
        }
    }

    /**
     * 随机生成一道四则运算题目
     * @param fractionNum 运算符个数
     * @return 二叉树
     */
    private Deposit build(int fractionNum){
        if(fractionNum == 0){
            return new Deposit(creator(),null,null);
        }
        ThreadLocalRandom random = ThreadLocalRandom.current();
        ChildDeposit node = new ChildDeposit(SYMBOLS [random.nextInt(4)],null, null);
        //左子树运算符数量
        int left = random.nextInt(fractionNum);
        //右子树运算符数量
        int right = fractionNum - left - 1;
        node.setLeft(build(left));
        node.setRight(build(right));
        Fraction value = calculate(node.getSymbol(),node.getLeft().getValue(),node.getRight().getValue());
        //负数处理
        if(value.Negative()){
            //交换左右子树，就是交换两个减数的顺序
            if (node != null) {
                Deposit swap = node.getLeft();
                node.setLeft(node.getRight());
                node.setRight(swap);
            }
            value = calculate(node.getSymbol(),node.getLeft().getValue(),node.getRight().getValue());
        }
        node.setValue(value);
        return node;
    }


    /**
     * 获取表达式，
     * 打印题目与答案
     */
    private String print(){
        return print(content) +  " = " + content.getValue();
    }

    private String print(Deposit node){
        if (node == null){
            return "";
        }
        String frac = node.toString();
        String left = print(node.getLeft());
        if (node.getLeft() instanceof ChildDeposit && node instanceof ChildDeposit) {
            if (bracketsLeft(((ChildDeposit) node.getLeft()).getSymbol(), ((ChildDeposit) node).getSymbol())) {
                left = "(" + " " + left + " " + ")";
            }
        }
        String right = print(node.getRight());
        if (node.getRight() instanceof ChildDeposit && node instanceof ChildDeposit) {
            if (bracketsRight(((ChildDeposit) node.getRight()).getSymbol(), ((ChildDeposit) node).getSymbol())) {
                right = "(" + " " + right + " " + ")";
            }
        }
        return left + frac + right;
    }
    /**
     * 比较两个符号谁优先级更高，子树的箱号优先级低要加括号，左括号or右括号
     */
    private boolean bracketsLeft(String left,String mid){
        return (left.equals("+")|| left.equals("-")) && (mid.equals("x")||mid.equals("\u00F7"));
    }
    private boolean bracketsRight(String right, String mid){
        return (right.equals("+")|| right.equals("-")) && (mid.equals("x")||mid.equals("\u00F7"))||(mid.equals("\u00F7"))||(mid.equals("-")&&(mid.equals("+")|| mid.equals("-")));
    }

    /**
     *生成一个题目，先调用下面的createAth方法来判断有没有生成一个用build方法生成的树
     */
    CreateAth(boolean isBuild){
        if(isBuild){
            ThreadLocalRandom random = ThreadLocalRandom.current();
            int kind = random.nextInt(4);
            if (kind == 0) kind = 1;
            content = build(kind);
            while (content.getValue().Zero()){
                content =build(kind);
            }
        }
    }

    /**
     * 查重
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CreateAth)) return false;
        CreateAth exercise = (CreateAth) o;
        return content.equals(exercise.content);
    }

    Fraction getResult() {
        return content.getValue();
    }

    ——————以下是判断题目所要调用到的方法———————————
    /**
     * 中缀表达式生成树,用栈的特点，把中缀表达式变成前缀表达式
     * 在判错中调用
     * @param exercise 中缀表达式
     * @return 二叉树
     */
    Deposit build(String exercise) {
        String[] strs = exercise.trim().split(" "); //拿走标号
        Stack<Deposit> depositStack = new Stack<>();  //结点栈
        StringStack symbolStack = new StringStack();  //符号栈
        //中缀表达式转换成前缀表达式，然后再用前序遍历生成数
        for (int i = strs.length - 1; i >= 0; i--) {
            String str = strs[i];
            if (!str.matches("[()+\\u00F7\\-x]")) {
                depositStack.push(new Deposit(new Fraction(str)));
            } else {
                //符号结点
                while (!symbolStack.empty() && ((symbolStack.peekString().equals("x") ||
                        symbolStack.peekString().equals("\u00F7"))
                        && (str.equals("+") || str.equals("-"))
                        || str.equals("("))) {
                    String symbol = symbolStack.popString();
                    if (symbol.equals(")")) {
                        break;
                    }
                    push(symbol, depositStack);
                }
                if (str.equals("(")) {
                    continue;
                }
                symbolStack.pushString(str);
            }
        }
        while (!symbolStack.empty()) {
            push(symbolStack.popString(), depositStack);
        }
        this.content = depositStack.pop();
        return content;
    }

    /**
     * 将符号压入节点栈且计算结果，仅在生成前缀表达式
     */
    private void push(String symbol, Stack<Deposit> nodeStack) {
        Deposit left = nodeStack.pop();
        Deposit right = nodeStack.pop();
        ChildDeposit node = new ChildDeposit(symbol, left, right);
        node.setValue(calculate(symbol, left.getValue(), right.getValue()));
        nodeStack.push(node);
    }
}

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();
    }
}

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);
    }

}

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;
    }
}

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;
    }
}

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();

        }
    }
}

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("结果：生成题目失败" );

            }
        }
    }
}

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("结果：生成题目失败" );

            }
        }
    }
}