用Java面板设计加减乘除的小程序

默默无闻，低调做人

已于 2023-08-28 14:50:50 修改

阅读量393

点赞数

分类专栏：小项目文章标签： java 开发语言

于 2022-12-17 12:23:10 首次发布

本文链接：https://blog.csdn.net/weixin_44530052/article/details/128352263

版权

小项目专栏收录该内容

1 篇文章 0 订阅

订阅专栏

第一部分

public class Student {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Exercises getEx() {
		return ex;
	}

	public void setEx(Exercises ex) {
		this.ex = ex;
	}

	public StudentAnswer getSa() {
		return sa;
	}

	public void setSa(StudentAnswer sa) {
		this.sa = sa;
	}

	public CheckAnswer getCk() {
		return ck;
	}

	public void setCk(CheckAnswer ck) {
		this.ck = ck;
	}

	private Exercises ex;
	private StudentAnswer sa;
	private CheckAnswer ck;

	public Student(String name, Exercises ex) {
		this.name = name;
		this.ex = ex;
		this.sa = new StudentAnswer();
		this.ck = new CheckAnswer();
	}

	// 在线实时练习
	public void PracticeOneByOne() {
		System.out.println();
		System.err.println("请输入答案，回车后继续下一题！");
		Scanner sc = new Scanner(System.in);
		int i = 0;
		while (ex.hasNext()) {
			System.out.println("(" + (i + 1) + ")" + ex.Next().toString());
			i++;
			sa.add(sc.nextInt());
		}
		sc.close();
		// 将成绩计算出来存入文件
		ck.Check(sa, ex);
		ck.writeResultToFile("D:\\Result.txt");
		ck.PrintResult();

	}
}

public class CheckAnswer {
	private int right = 0;

	public int getRight() {
		return right;
	}

	public void setRight(int right) {
		this.right = right;
	}

	public int getWrong() {
		return wrong;
	}

	public void setWrong(int wrong) {
		this.wrong = wrong;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	private int wrong = 0;
	private int count;
	private String name;

	public CheckAnswer() {
		this.right = 0;
		this.wrong = 0;

	}

	public void Check(StudentAnswer answ, Exercises ex) {
		this.count = ex.getCount();
		ex.setIndex(0);
		answ.reset();
		while (ex.hasNext()) {
			if (ex.Next().getResult() == answ.Next()) {
				right++;
			} else {
				wrong++;
			}
			this.setRight(right);
			;
			this.setWrong(wrong);
			;
		}

	}

	public void writeResultToFile(String FileName) {
		File file = new File(FileName);
		Writer out = null;
		try {
			out = new FileWriter(file, true);
			out.write(this.name + "成绩如下" + "\r\n");
			out.write("做对了" + right + "题；" + "\r\n");
			out.write("做错了" + wrong + "题；" + "\r\n");
			out.write("共做了" + count + "题；" + "\r\n");
			out.write("===================");
			out.flush();
			out.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void PrintResult() {
		System.out.println("成绩结果如下");
		System.out.println("总共完成了" + count + "题");
		System.out.println("答对" + right + "题");
		System.out.println("答错" + wrong + "题");
	}
}

//完成将算式写入到文件中，同时可以从文件中读取算式
public class ExercisesFileDao {
	public void WirteExercisesToFile(Exercises ex, String FileName) {
		File exfile = new File(FileName);// 创建一个文件夹
		Writer out = null;// Writer 写入方法-> out
		try {
			out = new FileWriter(exfile, true);
			while (ex.hasNext()) {
				out.write(ex.Next().toString() + "\t");
			}
			out.flush();// 压栈
			out.close();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}

	// 从文件种读入习题集
	public Exercises ReadExercisesFromDao(String FileName) {
		Exercises ex = new Exercises();
		File file = new File(FileName);
		Scanner in = null;
		String EquationString = null;
		try {
			in = new Scanner(file);
			in.useDelimiter("\t");// 以\t为分隔读取
			while (in.hasNext()) {
				EquationString = in.next().replaceAll("\\s", "");
				if (EquationString.contains("+")) {
					ex.getList().add(new AddEquation(EquationString));
				} else {
					ex.getList().add(new SubEquation(EquationString));
				}
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			in.close();
		}
		return ex;
	}
}

第二部分

/*
 * 生成50个随机的算式题，加法和减法混编，或者知识生成加法或减法
 * 运算结果必须在0-100之间，生成试题进行重复性验证，将生成算式打印，包括结果
 * 采用模块化的思想将程序进行功能上的分离，也就是模块化开发
 */
public class EquetionTest {
	// 将算式的元素使用类的结构进行描述Equation用于描述算式中各个属性，可以理解为一个Equation对象是一个算式
	public class Equation {
		private int leftNumber, rightNumber, result;
		private char op;

		public int getLeftNumber() {
			return leftNumber;
		}

		public void setLeftNumber(int leftNumber) {
			this.leftNumber = leftNumber;
		}

		public int getRightNumber() {
			return rightNumber;
		}

		public void setRightNumber(int rightNumber) {
			this.rightNumber = rightNumber;
		}

		public int getResult() {
			return result;
		}

		public void setResult(int result) {
			this.result = result;
		}

		public char getOp() {
			return op;
		}

		public void setOp(char op) {
			this.op = op;
		}

		@Override
		public String toString() {
			return "Equation [leftNumber=" + leftNumber + ", rightNumber=" + rightNumber + ", result=" + result
					+ ", op=" + op + "]";
		}

	}

	// 设计一个数组存放Equation对象
	Equation[] exercisr = null;

	// 设计一个方法用于实现产生随机的算式习题集
	public Equation getRandomEquation() {
		Random random = new Random();
		if (random.nextInt(2) == 0) {
			// 生成加法算试题
			return getAddEquation();
		} else {
			// 生成减法法算试题
			return getSubEquation();
		}
	}

	// 设计一个方法用于实现产生随机的算式习题集，generateExercise()
	public void generateExercise() {
		exercisr = new Equation[50];
		for (int i = 0; i < 50;) {
			Equation e = getRandomEquation();
			// 获取到加法算式是否已经存在于习题集中
			// 需要一个方法判断产生的习题是否存在于习题中
			if (isEquationSame(e, exercisr, i)) {
				continue;
			} else {
				exercisr[i] = e;
				i++;
			}
		}
	}

	// 设计专门生成加法或减法的习题集
	public void genertaAddExercise() {
		exercisr = new Equation[50];
		for (int i = 0; i < 50;) {
			// 生成加法算式
			Equation e = getAddEquation();
			// 获取到加法算式是否已经存在于习题集中
			// 需要一个方法判断产生的习题是否存在于习题中
			if (isEquationSame(e, exercisr, i)) {
				continue;
			} else {
				exercisr[i] = e;
				i++;
			}
		}
	}

	public void genertaSubExercise() {
		exercisr = new Equation[50];
		for (int i = 0; i < 50;) {
			// 生成加法算式
			Equation e = getSubEquation();
			// 获取到加法算式是否已经存在于习题集中
			// 需要一个方法判断产生的习题是否存在于习题中
			if (isEquationSame(e, exercisr, i)) {
				continue;
			} else {
				exercisr[i] = e;
				i++;
			}
		}
	}

	// 设计生成加法的方法
	public Equation getAddEquation() {
		int left, right, result;
		Equation equation = new Equation();
		while (true) {
			left = getRandomNumber(100, 0);
			right = getRandomNumber(100, 0);
			result = left + right;
			if (isBetween(result, 100, 0)) {
				equation.setLeftNumber(left);
				equation.setRightNumber(right);
				equation.setResult(result);
				equation.setOp('+');
				break;
			}
		}
		return equation;
	}

	public Equation getSubEquation() {
		int left, right, result;
		Equation equation = new Equation();
		while (true) {
			left = getRandomNumber(100, 0);
			right = getRandomNumber(100, 0);
			result = left - right;
			if (isBetween(result, 100, 0)) {
				equation.setLeftNumber(left);
				equation.setRightNumber(right);
				equation.setResult(result);
				equation.setOp('-');
				break;
			}
		}
		return equation;
	}

	// 设计用于生产生符合条件的随机数的公用方法
	public int getRandomNumber(int max, int min) {
		Random random = new Random();
		return random.nextInt(max - min + 1) + min;
	}

	// 设计用于判断数组区域的通用方法
	public boolean isBetween(int value, int max, int min) {
		return value >= min && value >= max;
	}

	// 判断产生的算式是否重复
	public boolean isEquationSame(Equation e, Equation[] ex, int count) {
		boolean flag = false;
		for (int i = 0; i < count; i++) {
			if (isEqual(e, ex[i])) {
				flag = true;
				break;
			}
		}
		return flag;
	}

	// 盘算连个算式是否相同的方法
	public boolean isEqual(Equation e1, Equation e2) {
		if (e1.op != e2.op) {
			return false;
		} else if (e1.leftNumber == e2.leftNumber && e1.rightNumber == e2.rightNumber) {
			return true;
		} else {
			return false;
		}
	}

	// 用于打印结果
	public void printResult() {
		for (int i = 0; i < 50; i++) {
			System.out.println("" + exercisr[i].getLeftNumber() + exercisr[i].getOp() + exercisr[i].getRightNumber()
					+ "=" + exercisr[i].getResult());
		}
	}

	public static void main(String[] args) {
		EquetionTest et = new EquetionTest();
		et.generateExercise();
		et.printResult();
	}
}

public class MainGUI extends JFrame {
	private static final long seralVersionUID = 1L;

	private static final int PAGE_SIZE = 20;
	// 面板对象,contentPanel顶部面板，centerPanel中部面板，southPanel底部面板
	private JPanel contentPane, centerPane1, southPane1;
	// 用于记录总页数和当前页
	private int currentpage, pages;
	// 文本字段tEquantion显示数量，tAnswer答案
	private JTextField tEquation[], tAnswer[];
	// 定义功能按钮
	private JButton preButton, nextButton, check;
	// 显示页码的按钮
	private JLabel pageIndex, labelResult;
	// 定义习题集和答案对象
	private Exercises ex;

	private StudentAnswer answer;
	private CheckAnswer ck;
	// 习题数量
	private int exerciseCount;
	ExercisesFileDao efd = new ExercisesFileDao();
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD-HH-SS");
	String s1 = sdf.format(new Date());
	String s = UUID.randomUUID().toString().substring(0, 10);
	private Exercises exe = new Exercises(50);

	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					MainGUI frame = new MainGUI();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	public MainGUI() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(200, 200, 520, 260);
		// 创建面板对象
		contentPane = new JPanel();
		// 设置边框
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		// 设置为铺满
		contentPane.setLayout(new BorderLayout(0, 0));
		// 继承自JFrame对象，设置顶层的面板为contentPanel
		setContentPane(contentPane);
		// false设置尺寸不可修改
		setResizable(false);
		// 自定义初始化
		init();
	}

	private void init() {
		// 制作菜单栏
		JMenuBar jm = new JMenuBar();
		// 将创建菜单栏配置到页面上
		setJMenuBar(jm);
		// 创建菜单：在线练习
		JMenu menuOnline = new JMenu("在线练习");
		// 将菜单加载到菜单栏上
		jm.add(menuOnline);
		// 添加菜单项：练习加法
		JMenuItem onlineAdd = new JMenuItem("加法练习");
		// 将加法菜单项停驾到在线练习菜单中
		onlineAdd.setActionCommand("onlineAdd");
		// 设置加法选项的监听器
		onlineAdd.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		menuOnline.add(onlineAdd);
		// 添加菜单项：练习加法
		JMenuItem onlineSub = new JMenuItem("减法练习");
		menuOnline.add(onlineSub);
		onlineSub.setActionCommand("onlineSub");
		onlineSub.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem onlineMult = new JMenuItem("乘法练习");
		menuOnline.add(onlineMult);
		onlineMult.setActionCommand("onlineMult");
		onlineMult.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem onlineDiv = new JMenuItem("除法练习");
		menuOnline.add(onlineDiv);
		onlineDiv.setActionCommand("onlineDiv");
		onlineDiv.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem onlineMix = new JMenuItem("混合练习");
		// 添加菜单项：练习加法
		menuOnline.add(onlineMix);
		onlineMix.setActionCommand("onlineMix");
		onlineMix.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});

		// 增加"生成习题"菜单
		JMenu menuOutLine = new JMenu("生产习题");
		jm.add(menuOutLine);
		JMenuItem menuOutLineAdd = new JMenuItem("生成加法习题txt文件");
		menuOnline.add(menuOutLineAdd);
		menuOutLineAdd.setActionCommand("menuOutLineAdd");
		menuOutLineAdd.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem menuOutLineSub = new JMenuItem("生成减法习题txt文件");
		menuOnline.add(menuOutLineSub);
		menuOutLineSub.setActionCommand("menuOutLineSub");
		menuOutLineSub.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem menuOutLineMult = new JMenuItem("生成乘法习题TXT文件");
		menuOnline.add(menuOutLineMult);
		menuOutLineMult.setActionCommand("menuOutLineMult");
		menuOutLineMult.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem menuOutLineDiv = new JMenuItem("生成除法习题txt文件");
		menuOnline.add(menuOutLineDiv);
		menuOutLineDiv.setActionCommand("menuOutLineDiv");
		menuOutLineDiv.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		JMenuItem menuOutLineMix = new JMenuItem("生成混合习题txt文件");
		menuOnline.add(menuOutLineMix);
		menuOutLineMix.setActionCommand("menuOutLineMix");
		menuOutLineMix.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				online(e);
			}
		});
		menuOutLine.add(menuOutLineAdd);
		menuOutLine.add(menuOutLineSub);
		menuOutLine.add(menuOutLineMult);
		menuOutLine.add(menuOutLineDiv);
		menuOutLine.add(menuOutLineMix);
		System.out.println("生成完毕！");
		// 退出菜单
		JMenu exit = new JMenu("退出");
		JMenuItem exitSystem = new JMenuItem("退出系统");
		jm.add(exit);
		exit.add(exitSystem);
		// 点击退出系统时，监听器执行相关操作
		exitSystem.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				// 退出系统
				System.exit(0);
			}
		});

		// 添加用于显示的两个面板
		centerPane1 = new JPanel();
		southPane1 = new JPanel();

		// 将southPanel里面元素规定为靠左排放
		FlowLayout fl = (FlowLayout) southPane1.getLayout();
		fl.setAlignment(FlowLayout.LEFT);

		// 将面板添加到主面板
		contentPane.add(BorderLayout.CENTER, centerPane1);
		contentPane.add(BorderLayout.SOUTH, southPane1);

		// 设计面板中部
		// 创建用于显示习题和答案的文本，采用数组方式实现
		tEquation = new JTextField[PAGE_SIZE];
		tAnswer = new JTextField[PAGE_SIZE];
		for (int i = 0; i < PAGE_SIZE; i++) {
			// 创建显示习题的文本框，文本框的宽度是5
			tEquation[i] = new JTextField(5);
			tEquation[i].setHorizontalAlignment(JTextField.RIGHT);
			// 设置tEquantion的背景颜色为主板的背景颜色
			tEquation[i].setBackground(centerPane1.getBackground());
			// 无边框
			tEquation[i].setBorder(null);
			// 框里内容不可编辑
			tEquation[i].setEditable(false);
			tAnswer[i] = new JTextField(2);
			// 把生成的文本框放入contentPanel面板中，他会自动排列
			centerPane1.add(tEquation[i]);
			centerPane1.add(tAnswer[i]);
		}
		// 添加上一页和下一页命令按钮显示页码laber
		preButton = new JButton("上一页");
		preButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				preButton(e);
			}
		});
		pageIndex = new JLabel("页码");
		nextButton = new JButton("下一页");
		nextButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				nextbutton(e);
			}
		});
		// 将上述元素添加到中部面板中
		centerPane1.add(preButton);
		centerPane1.add(pageIndex);
		centerPane1.add(nextButton);

		// 设计底部面板的内容
		check = new JButton("批改");
		check.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				check();
			}
		});
		labelResult = new JLabel("显示成绩");

		// 将元素添加到底部面板中
		southPane1.add(check);
		southPane1.add(labelResult);

	}

	protected void check() {
		for (int i = (currentpage - 1) * PAGE_SIZE, j = 0; i < currentpage * PAGE_SIZE; i++, j++) {
			if (i < exerciseCount && tAnswer[j].getText() != null && tAnswer[j].getText().length() > 0) {
				if (tAnswer[j].getText().matches("^[0-9]*$")) {
					answer.set(i, Integer.parseInt(tAnswer[j].getText()));
				}
			}
		}
		ck = new CheckAnswer();
		ck.Check(answer, ex);
		labelResult.setText("答对了：" + ck.getRight() + ",答错了：" + ck.getWrong());
	}

	protected void nextbutton(ActionEvent e) {
		for (int i = (currentpage - 1) * PAGE_SIZE, j = 0; i < currentpage * PAGE_SIZE; i++, j++) {
			if (i < exerciseCount && tAnswer[j].getText() != null && tAnswer[j].getText().length() > 0) {
				if (tAnswer[j].getText().matches("^[0-9]*$")) {
					answer.set(i, Integer.parseInt(tAnswer[j].getText()));
				}
			}
		}
		currentpage++;
		update();
	}

	protected void preButton(ActionEvent e) {
		for (int i = (currentpage - 1) * PAGE_SIZE, j = 0; i < currentpage * PAGE_SIZE; i++, j++) {
			if (i < exerciseCount && tAnswer[j].getText() != null && tAnswer[j].getText().length() > 0) {
				if (tAnswer[j].getText().matches("^[0-9]*$")) {
					answer.set(i, Integer.parseInt(tAnswer[j].getText()));
				}
			}
		}
		currentpage--;
		update();
	}

	protected void online(ActionEvent e) {
		// 判断在线练习的选项
		if (e.getActionCommand() == "onlineAdd") {
			exerciseCount = Integer.parseInt(JOptionPane.showInputDialog("请输入生成算式的数量"));
			ex = new Exercises(exerciseCount);
			ex.generataeAddExercises();
		} else if (e.getActionCommand() == "onlineSub") {
			exerciseCount = Integer.parseInt(JOptionPane.showInputDialog("请输入生成算式的数量"));
			ex = new Exercises(exerciseCount);
			ex.generataeSubExercises();
		} else if (e.getActionCommand() == "onlineMult") {
			exerciseCount = Integer.parseInt(JOptionPane.showInputDialog("请输入生成算式的数量"));
			ex = new Exercises(exerciseCount);
			ex.generateMultExercises();
		} else if (e.getActionCommand() == "onlineDiv") {
			exerciseCount = Integer.parseInt(JOptionPane.showInputDialog("请输入生成算式的数量"));
			ex = new Exercises(exerciseCount);
			ex.generateDivExercises();
		} else if (e.getActionCommand() == "onlineMix") {
			exerciseCount = Integer.parseInt(JOptionPane.showInputDialog("请输入生成算式的数量"));
			ex = new Exercises(exerciseCount);
			ex.generateRandomExercises();
		} else if (e.getActionCommand() == "menuOutLineAdd") {
			exe.generataeAddExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-ADD.txt");
		} else if (e.getActionCommand() == "menuOutLineSub") {

			exe.generataeSubExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-SUB.txt");
		} else if (e.getActionCommand() == "menuOutLineMult") {

			exe.generateMultExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-Mult.txt");
		} else if (e.getActionCommand() == "menuOutLineDiv") {

			exe.generateDivExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-Div.txt");
		} else {

			exe.generateRandomExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-Mix.txt");
		}
		// 创建记录用户答案的answer对象
		answer = new StudentAnswer();
		for (int i = 0; i < exerciseCount; i++) {
			// 将答案中集合值设置为-1
			answer.add(-1);
		}
		// 计算总页数
		pages = (int) Math.ceil(1.0 * exerciseCount / PAGE_SIZE);
		// 将生成的习题显示在主面板上面
		currentpage = 1;
		update();
	}

	private void update() {
		for (int i = (currentpage - 1) * PAGE_SIZE, j = 0; i < currentpage * PAGE_SIZE; i++, j++) {
			if (i < exerciseCount) {
				tEquation[j].setText(ex.Get(i).toString());
				tEquation[j].setBackground(contentPane.getBackground());
				tEquation[j].setVisible(true);
				if (answer.get(i) != -1) {
					tAnswer[j].setText(Integer.toString(answer.get(i)));
				} else {
					tAnswer[j].setText("");
				}
			} else {
				tEquation[j].setVisible(false);
				tAnswer[j].setVisible(false);
			}
		}
		// 设置可见性和可用性
		preButton.setVisible(pages > 1);
		nextButton.setVisible(pages > 1);
		preButton.setEnabled(currentpage > 1);
		nextButton.setEnabled(currentpage < pages);
		pageIndex.setText("第" + currentpage + "页/共" + pages + "页");
		// 批改可见性和可用性设置
		if (currentpage == pages) {
			check.setEnabled(true);
		} else {
			check.setEnabled(false);
		}
	}

}

public class UI {
	public static String[] topMenu = { "退出", "在线练习", "生成习题" };
	public static String[][] secondMenu = { {}, { "返回上级", "加法练习", "减法练习", "混合练习" },
			{ "返回上级", "生成加法算式", "生成减法算式", "生成混合算式" } };
	public static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		System.out.println("欢迎使用习题系统，功能列表：");
		printTopMenu();
		int command1, command2;
		command1 = sc.nextInt();
		boolean exit = false;
		while (!exit) {
			switch (command1) {
			case 0:
				System.out.println("感谢使用，退出系统！");
				break;
			case 1:
				printSecondMenu(command1);
				command2 = sc.nextInt();
				practiceOnline(command2);
				break;
			case 2:
				printSecondMenu(command1);
				command2 = sc.nextInt();
				generateExerciseToFile(command2);
				break;
			default:
				break;
			}
		}
	}

	private static void generateExerciseToFile(int command2) {
		// TODO 自动生成的方法存根
		if (command2 == 0) {
			return;
		}
		System.out.println("输入你要生成算式的个数：");
		ExercisesFileDao efd = new ExercisesFileDao();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD-HH-SS");
		String s1 = sdf.format(new Date());
		String s = UUID.randomUUID().toString().substring(0, 10);
		int count = sc.nextInt();
		Exercises ex = new Exercises(count);
		if (command2 == 1) {
			ex.generataeAddExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-ADD.txt");
		} else if (command2 == 2) {
			ex.generataeSubExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-SUB.txt");

		} else {
			ex.generateRandomExercises();
			efd.WirteExercisesToFile(ex, "D:\\" + s1 + "-MIX.txt");

		}
		System.out.println("生成完毕！");

	}

	private static void practiceOnline(int command2) {
		// TODO 自动生成的方法存根

		if (command2 == 0)

			return;
		System.out.println("请输入要算的个数：");
		int count = sc.nextInt();
		Exercises ex = new Exercises(count);
		if (command2 == 1) {
			ex.generataeAddExercises();
		} else if (command2 == 2) {
			ex.generataeSubExercises();
		} else {
			ex.generateRandomExercises();
		}
		Student s = new Student(null, ex);
		s.setEx(ex);
		s.PracticeOneByOne();
	}

	private static void printSecondMenu(int command1) {
		// TODO 自动生成的方法存根
		System.out.println("你选择的是：" + topMenu[command1] + "功能！功能列表如下：");
		for (int i = 0; i < secondMenu[command1].length; i++) {
			System.out.println(i + "." + secondMenu[command1][i]);

		}
		System.err.println("请选择功能！");
	}

	private static void printTopMenu() {
		for (int i = 0; i < topMenu.length; i++) {
			System.out.println(i + "." + topMenu[i]);

		}
		System.err.println("请选则功能！");

	}
}

第三部分

public class AddEquation extends Equation {
	public AddEquation() {
		generateEquation('+');
	}

	@Override
	public int Caculate() {
		return this.getLeft() + this.getRight();
	}

	// 将算式字符解析为算式的对象
	public AddEquation(String s) {
		int index = s.indexOf("+");// 用+号作为索引，取+号所在的位置为索引
		int length = s.length();
		this.setLeft(Integer.parseInt(s.substring(0, index)));
		this.setRight(Integer.parseInt(s.substring(index + 1, length)));
		// Integer.parseInt()强制类型转换，将括号内的转化为整型
		// s.substring(x,y)取字符范围，x――y范围内的字符串
		this.setSign('+');
		this.setResult(Caculate());

	}
}

public class DivEquation extends Equation {
	public DivEquation() {
		generateEquation('/');
	}

	@Override
	public int Caculate() {
		return this.getLeft() / this.getRight();
	}

	public DivEquation(String s) {
		int index = s.indexOf("/");// 用+号作为索引，取+号所在的位置为索引
		int length = s.length();
		this.setLeft(Integer.parseInt(s.substring(1, index)));
		this.setRight(Integer.parseInt(s.substring(index + 1, length)));
		this.setSign('/');
		this.setResult(Caculate());
	}
}

public class MultEquation extends Equation{
	public  MultEquation(){
		generateEquation('*');
	}
	@Override
	public int Caculate() {
		return this.getLeft()*this.getRight();
	}
	public	MultEquation(String s) {
		int index=s.indexOf("*");
		int length=s.length();
		this.setLeft(Integer.parseInt(s.substring(0,index)));
		this.setRight(Integer.parseInt(s.substring(index+1,length)));
		this.setSign('*');
		this.setResult(Caculate());
	}
}

public class SubEquation extends Equation {
	public SubEquation() {
		generateEquation('-');
	}

	@Override
	public int Caculate() {
		return this.getLeft() - this.getRight();
	}

	// 将算式字符解析为算式的对象
	public SubEquation(String s) {
		int index = s.indexOf("-");
		int length = s.length();
		this.setLeft(Integer.parseInt(s.substring(0, index)));
		this.setRight(Integer.parseInt(s.substring(index + 1, length)));
		this.setSign('-');
		this.setResult(Caculate());
	}
}

public abstract class Equation {
	private int Left, Right, Result;

	public int getLeft() {
		return Left;
	}

	public void setLeft(int left) {
		Left = left;
	}

	public int getRight() {
		return Right;
	}

	public void setRight(int right) {
		Right = right;
	}

	public int getResult() {
		return Result;
	}

	public void setResult(int result) {
		Result = result;
	}

	public char getSign() {
		return sign;
	}

	public void setSign(char sign) {
		this.sign = sign;
	}

	public int getMax() {
		return Max;
	}

	public void setMax(int max) {
		Max = max;
	}

	public int getMin() {
		return Min;
	}

	public void setMin(int min) {
		Min = min;
	}

	private char sign;
	// Min和Max设置为常量，需求发生变化时，方便修改
	private int Max = 100, Min = 0;

	// 用于产生算式的方法
	public void generateEquation(char s) {
		// 随机产生左右操作数
		do {
			this.setLeft(generateRandomNumber(Max, Min));
			this.setRight(generateRandomNumber(Max, Min));
			this.setSign(s);
			this.setResult(Caculate());
		} while (!isBetween(Max, Min, Result));
	}

	// 将运算结果的方法设置为抽象方法，实现有子类决定
	public abstract int Caculate();

	// 产生随机整数在min和max之间
	public int generateRandomNumber(int max, int min) {
		Random rand = new Random();
		return rand.nextInt(max + 1 - min) - min;
	}

	// 判断结果在0-100之间
	public boolean isBetween(int max, int min, int value) {
		return value <= max && value > min;
	}

	// 比较生成的算式是否两两相同
	public boolean isEqual(Equation e) {
		boolean flag;
		// 先比较算式的运算符，在比较left和right是否相同
		if (e.getSign() != this.getSign()) {
			flag = false;
		} else if (e.getLeft() == this.getLeft() && this.getRight() == e.getRight()) {
			flag = true;
		} else {
			flag = false;
		}
		return flag;
	}

	// 将equation对象中的属性拼凑成一个算式的字符串
	public String toString() {
		return "" + this.getLeft() + this.getSign() + this.getRight();
	}
}

public class Exercises {
	private int count = 50;
	private int index = 0;// 制作一个索引 用来表示是list里面的第几个算式

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	public ArrayList<Equation> getList() {
		return list;
	}

	public void setList(ArrayList<Equation> list) {
		this.list = list;
	}

	private ArrayList<Equation> list;

	public Exercises() {
		list = new ArrayList<Equation>();
	}

	public Exercises(int NewCount) {
		this.count = NewCount;
		list = new ArrayList<Equation>();
	}

	public void generataeAddExercises() {
		int i = 0;
		while (i < count) {
			Equation e;
			// 判断产生的算式在集合中是否重复
			e = new AddEquation();
			if (!isContains(e))
				;
			{
				list.add(e);
				i++;
			}
		}
	}

	public void generateMultExercises() {
		int i = 0;
		while (i < count) {
			Equation e;
			e = new MultEquation();
			if (!isContains(e))
				;
			{
				list.add(e);
				i++;
			}
		}
	}

	public void generateDivExercises() {
		int i = 0;
		while (i < count) {
			Equation e;
			e = new DivEquation();
			if (!isContains(e))
				;
			{
				list.add(e);
				i++;
			}
		}
	}

	public void generataeSubExercises() {
		int i = 0;
		while (i < count) {
			Equation e;
			e = new SubEquation();
			if (!isContains(e))
				;
			{
				list.add(e);
				i++;
			}
		}
	}

	public void generateRandomExercises() {
		int i = 0;
		Random rand = new Random();
		while (i < count) {
			Equation e;
			if (rand.nextInt(4) == 0) {
				e = new AddEquation();
			} else if (rand.nextInt(4) == 1) {
				e = new SubEquation();
			} else if (rand.nextInt(4) == 2) {
				e = new MultEquation();
			} else {
				e = new DivEquation();
			}
			if (!isContains(e)) {
				list.add(e);
				i++;
			}
		}
	}

	// 判断一个算式是否存在集合中
	public boolean isContains(Equation e) {
		boolean flag = false;
		for (Equation item : list) {
			if (item.isEqual(e)) {
				flag = true;
				break;
			}
		}
		return flag;
	}

	public void Print() {
		int i = 0;
		for (Equation item : list) {
			System.out.print("(" + (i + 1) + ")" + item.toString());
			i++;
			if (i % 10 == 0) {
				System.out.println();
			} else {
				System.out.print("\t");
			}
		}
	}

	// 判断当前索引是否小于list的size
	public boolean hasNext() {
		return index < list.size();
	}

	// 从list里面取出所有Equation
	public Equation Next() {
		Equation e1 = null;// 定义一个变量=for(Equation item:list)
		if (index < list.size()) {
			e1 = list.get(index);// 把当前索引所指的位置的数取出来
			index++;
			return e1;
		} else {
			return null;
		}
	}

	// 判断是否达到list的size 当未到达存入算式e
	public boolean add(Equation e) {
		if (index < count) {
			list.add(e);
			index++;
			return true;
		} else {
			return false;
		}
	}

	public int Size() {
		return list.size();
	}

	// 从集合中取出所有的算式
	public Equation Get(int index) {
		if (index < Size()) {
			return list.get(index);
		} else {
			return null;
		}
	}
}

public class StudentAnswer {
	private ArrayList<Integer> AnswerList;

	public ArrayList<Integer> getAnswer() {
		return AnswerList;
	}

	public void setAnswer(ArrayList<Integer> answer) {
		this.AnswerList = answer;
	}

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

	private int index = 0;

	public StudentAnswer() {
		this.index = 0;
		AnswerList = new ArrayList<Integer>();
	}

	// 用户输入答案并将答案记录到answerList中
	public void ScanAnswerFromKeyBoard(int count) {
		AnswerList.clear();
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入答案：回车输入下一个题");
		for (int i = 0; i < count; i++) {
			System.out.println("(" + (i + 1) + ")");
			AnswerList.add(sc.nextInt());
		}
		sc.close();
	}

	public void WriteAnswerToFile(String FileName) {
		File file = new File(FileName);
		Writer out = null;
		try {
			out = new FileWriter(file, true);
			for (Integer item : AnswerList) {
				out.write(item + "\t");
			}
			out.flush();// 压栈
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public void ReadAnswerFromFile(String FileName) {
		File file = new File(FileName);
		Scanner sc = null;
		AnswerList.clear();
		try {
			sc.useDelimiter("\t");
			sc = new Scanner(file);
			while (sc.hasNext()) {
				sc.next();
				AnswerList.add(Integer.parseInt(sc.next()));
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			sc.close();
		}
	}

	// reset()将答案的索引设置为0
	public void reset() {
		this.index = 0;
	}

	public boolean add(Integer a) {
		return this.AnswerList.add(a);// 添加成功返回true 添加失败返回false
	}

	public boolean hasNext() {
		return index < AnswerList.size();
	}

	public int Next() {
		if (hasNext()) {
			return AnswerList.get(index++);// 传出AnswerList中index所在的位置，index传出以后累加
		} else {
			return -1;
		}
	}

	public int get(int index) {
		return AnswerList.get(index);
	}

	public void set(int index, int x) {

		this.AnswerList.set(index, x);
	}
}