小组开发，感谢组内大佬带我飞，我就是个做ppt的混子
说明：
①代码仅供参考，实现了课本上的所有功能并且通过了上台展示。
②编写用的eclipse，具体的文件路径结构已经不记得了。
③下面的代码是很多个Java程序放在一起了，想要用把代码顺一遍，找找文件的开始结尾位置。
④ 注释是个好东西，建议学弟学妹不要直接白嫖，尽量读一读代码。
更新于21年9月：
研一软件测试又用到了这个程序，把路径重新组装了一下，学弟学妹可以直接按照这个路径把代码拼起来，功能是没有问题的，使用时运行PracticeGui2程序就可以了。
package ExerciseTest;
public class AdditionOperation extends BinaryOperation{
AdditionOperation(){
generateBinaryOperation('+');
}
public boolean checkingCalculation(int anInteger){
//方法重写，使该类的算式符合规定的加法算式标准
if(anInteger<=upper)
return true;
else
return false;
}
int calculate(int left,int right){
return left + right;
}
}
class SubstractOperation extends BinaryOperation{
SubstractOperation(){
generateBinaryOperation('-');
}
public boolean checkingCalculation(int anInteger){
//方法重写，使该类的算式符合规定的减法算式标准
if(anInteger>=lower)
return true;
else
return false;
}
int calculate(int left,int right){
return left - right;
}
}
package ExerciseTest;
import java.io.Serializable;
import java.util.Random;
public abstract class BinaryOperation implements Serializable{
static final int upper = 100;
static final int lower = 0;
private int left_operand = 0,right_operand = 0;
private char operator = '+';
private int value = 0;
public void insert(String left, String right){
//新增：insert通过调用这个方法可以直接插入算式
left_operand = Integer.valueOf(left);
right_operand = Integer.valueOf(right);
value = calculate(left_operand, right_operand);
}
public void insert(int left, int right){
//新增：int参数的insert
left_operand = left;
right_operand = right;
value = calculate(left_operand, right_operand);
}
//重载public String toString
public String toString(){
String s;
String Charop = String.valueOf(operator);
s = left_operand+Charop+right_operand+"=";
return s;
}
// getXX 返回需要访问的数字和符号
public char getOperator(){
return operator;
}
public int getleft_operand(){
return left_operand;
}
public int getright_operand(){
return right_operand;
}
public int getvalue() {
return value;
}
protected void generateBinaryOperation(char anOperator){
//传入的anOperator即为该类生成的算式的运算符号
int left,right,result;
Random random = new Random();
left = random.nextInt(upper+1);
do{
//约束，两位整数必须符合约束条件才能赋值给成员函数
right = random.nextInt(upper+1);
result = calculate(left,right);
}while(!(checkingCalculation(result)));
left_operand = left;
right_operand = right;
operator = anOperator;
value = result;
}
abstract boolean checkingCalculation(int anInteger);
//检查是否符合算式标准
abstract int calculate(int left, int right);
//计算算式结果
public boolean equals(BinaryOperation anOperation){
//方法将该对象的数字符号与另一个对象的数字符号做比较，起到检查是否重复的作用
return operator==anOperation.getOperator()&&
right_operand==anOperation.getright_operand()&&
left_operand==anOperation.getleft_operand();
}
}
package ExerciseTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Exercise implements Serializable{
private static final long serialVersionUID = 6829563053067592708L;
private int OperationCount = 0;//新增：记录这个Exercise的算式总数
protected String FileName ;//新增：练习名称
public String Addr = "D:/加减法练习/";//新增：练习地址
private int current = 0;//记录当前访问位置
class Answers implements Serializable { //答案内部类
private static final long serialVersionUID = -232662116583465565L;
String content; //答案内容
boolean correct; //正确性
public Answers() {content = ""; correct = false;}
public Answers(String ans, boolean cr) {
content = ans; correct = cr;
}
}
private ArrayList<BinaryOperation> operationList = new ArrayList<BinaryOperation>();
private List <Answers> answers = new ArrayList<>(); //用户填写的所有题目的答案列表
private ExerciseType currentType; //当前题目类型，为串行化保存用
public ExerciseType getCurrentType() {return currentType;}
public String getExerciseType() {
String s = new String();
switch(currentType) {
case ADDandSUB:
s = "加减混合";
break;
case ADD:
s = "仅加法";
break;
case SUB:
s = "仅减法";
break;
}
return s;
}
private void setCurrentType(ExerciseType type) { this.currentType = type;}
public void setAnswer(int index, String ans) {
//设置答案内容并判断正确性
BinaryOperation op;
op = operationList.get(index); //获取算式
String result = String.valueOf(op.getvalue()); //获取正确结果
String tans = ans.trim();//获取用户输入的答案
answers.set(index, new Answers(tans, result.equals(tans)));
//设置答案内容和正确性，index位置上设置为对应的answer对象，对象里面保存用户答案和是否正确
}
public String getAnswer(int index) { //获取答案
return answers.get(index).content;
}
public void clearAnswers() { //清空答案（全设为空，错误）
for (int i = 0; i < answers.size(); i++)
answers.set(i, new Answers("", false));
}
public int Correct() { //统计正确题数
int correctAmount = 0;
for (int i = 0; i < answers.size(); i++) {
if (getJudgement(i))
correctAmount++;
}
return correctAmount;
}
public boolean getJudgement(int index) {
//获取判题结果
return answers.get(index).correct;
}
public void saveObject(String filename, Exercise exercise) throws ExerciseIOException{
//串行化存储对象
FileOutputStream f = null;
try {
f = new FileOutputStream(filename);
//可以传入一个字符串的文件地址,地址不为空时,自动为字符串创建File对象
} catch (FileNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
ObjectOutputStream s = null;
try {
s = new ObjectOutputStream(f);
//定义ObjectOutputStream对象需要用一个FileOutputStream来构造文件字节输出流对象
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
try {
s.writeObject(exercise);//向文件中输出算式
s.flush();
//刷新此输出流并强制写出所有缓冲的输出字节。
//flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
try {
s.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
public static Exercise loadObject(String filename) throws ExerciseIOException{
//串行化载入对象
FileInputStream in = null;
try {
in = new FileInputStream(filename);
} catch (FileNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
ObjectInputStream s = null;
try {
s = new ObjectInputStream(in);
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
Exercise exercise = null;
try {
exercise = (Exercise) s.readObject();
} catch (ClassNotFoundException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
try {
s.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return exercise;
}
public void generateWithFormerType(int operationCount) {
//采用原题型生成新题目
switch(currentType) {
case ADDandSUB:
this.generateBinaryExercise(operationCount);
break;
case ADD:
this.generateAdditionExercise(operationCount);
break;
case SUB:
this.generateBinaryExercise(operationCount);
break;
}
}
public enum ExerciseType {
ADD , SUB, ADDandSUB,
}
//重构结束
//创建一个关于BinaryOperation（算式）的动态数组
public Exercise() {
File aFile = new File(Addr);
if(!aFile.exists())
aFile.mkdir();
}
public boolean hasNext(){
return current<=operationList.size()-1;
}//若数组还有元素，则返回是，否则返回否
public BinaryOperation next(){
return operationList.get(current++);
}//若有元素，返回当前元素，当前访问位置移动到下一个位置
public boolean contains(BinaryOperation anOperation){
boolean flag = true;
int size = operationList.size();
if(size==0){//如果数组里没有算式，返回false，允许加入数组
return false;
}
for(int i = 0;i<size;i++){//将数组里已有的算式和新生成的算式做比较，检查是否存在重复
if(!operationList.get(i).equals(anOperation)){
flag = false;
}
}
return flag;
}
private BinaryOperation generateOperation(){
//随机生成一个加法或者减法算式并返回
Random random = new Random();
int opValue = random.nextInt(2);
if(opValue==1){
return new AdditionOperation();
}
return new SubstractOperation();
}
public void generateBinaryExercise(int operationCount){
//方法调用generateOperation，将随机生成的加法或者减法算式加入到动态数组中
setCurrentType(ExerciseType.ADDandSUB ); //设置题目类型
operationList.clear();
answers.clear();
current = 0;
OperationCount = operationCount;
FileName="MixOperation_exercise_"+operationCount+"_";
BinaryOperation anOperation;
while(operationCount>0){
do{
anOperation = generateOperation();
}while(contains(anOperation));
operationList.add(anOperation);
answers.add(new Answers());
//将anOperation 加入到Exercise中
operationCount--;
}
}
public void generateAdditionExercise(int operationCount){
//随机生成加法算式并加入数组
setCurrentType(ExerciseType.ADD ); //设置题目类型
answers.clear();
operationList.clear();
current = 0;
OperationCount = operationCount;
FileName= "Addition_exercise_"+operationCount+"_";
BinaryOperation anOperation1;
while(operationCount>0){
do{anOperation1 = new AdditionOperation();}while(contains(anOperation1));
operationList.add(anOperation1);//将anOperation 加入到Exercise中
answers.add(new Answers());
operationCount--;
}
}
public void generateSubstractExercise(int operationCount){
//随机生成减法算式并加入数组
setCurrentType(ExerciseType.SUB );
operationList.clear();
answers.clear();
operationList.clear();
current = 0;
OperationCount = operationCount;
FileName= "Substract_exercise_"+operationCount+"_";
BinaryOperation anOperation1;
while(operationCount>0){
do{anOperation1 = new SubstractOperation();}while(contains(anOperation1));
operationList.add(anOperation1);
answers.add(new Answers());
//将anOperation 加入到Exercise中
operationCount--;
}
}
public void writeCSVExercise()//生成文件
{
int count = OperationCount;//算式数量
FileName = Addr + FileName+".csv";//生成习题文件名称
String PracticeName = FileName.replaceAll("exercise", "practice");
System.out.println(FileName);
System.out.println(PracticeName);
try {
File file =new File(FileName);
if(!file.exists()){
file.createNewFile();
}
File pfile = new File(PracticeName);
if(!pfile.exists()) {
pfile.createNewFile();
}
FileWriter fileWritter = new FileWriter(file,false);
for(int i=0;i<count;i++)
{
fileWritter.write(operationList.get(i).toString());//把算式转换为字符串形式然后输出到文档里面
fileWritter.write(",");
if((i+1)%5==0)
fileWritter.write("\r\n");
}
System.out.println("习题文件已生成");
fileWritter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void readCSVExercise(File aFile)throws Exception{
//从习题文件中将习题读入程序中
FileName = aFile.getName();
operationList.clear();
current = 0;
String eqString = "";
BinaryOperation op;
FileInputStream in = new FileInputStream(aFile);
int b = 0;
while(b!=-1){
b = in.read();
if((char)b==','){
op = AddSubOperation(eqString);
Add(op);
eqString = "";
}else if(b!='\r'&&b!='\n')
eqString+=(char)b;
}
System.out.println("习题已经读入");
in.close();
}
void Add(BinaryOperation op) {
//Add方法，将一个算式加入到exercise中
operationList.add(op);
OperationCount++;
}
//以下是像阶段一一样直接生成算式，并没有调用算式基
public void writeCSVAdditionEercise(int count)
//随机生成加法习题
{
generateAdditionExercise(count);//生成习题
writeCSVExercise();//输出成文件
}
public void writeCSVSubstractEercise(int count)
//随机生成减法习题
{
generateSubstractExercise(count);//生成习题
writeCSVExercise();//输出成文件
}
public void writeCSVBinaryEercise(int count)
//随机生成混合习题
{
generateBinaryExercise(count);//生成习题
writeCSVExercise();//输出成文件
}
static boolean AddOrSub(String s){
//传入一个字符串，判断该字符串是加法还是减法
int pos = s.indexOf("+");
if(pos!=-1)
return true;//加法
else
return false;//减法
}
public static BinaryOperation AddSubOperation(String s){
//传入一个算式字符串，将该字符串转换成算式对象，返回这个算式对象
BinaryOperation bo;
String left,right;
int len = s.length();
int pos;
if(AddOrSub(s)){
pos = s.indexOf('+');
bo = new AdditionOperation();
}
else{
pos = s.indexOf('-');
bo = new SubstractOperation();
}
left = s.substring(0,pos);
right = s.substring(pos+1,len-1);
bo.insert(left,right);
return bo;
}
public BinaryOperation getOperation (int index) {
if (index < operationList.size())
return operationList.get(index);
else
return null;
}
public int length() {
return OperationCount;
}
}
package ExerciseTest;
public class ExerciseIOException extends Exception{
private static final long serialVersionUID = 2854125389344801376L;
//private static final long serialVersionUID = 1303843378304889051L;
public ExerciseIOException() {}
public ExerciseIOException(String msg) {super(msg);}
}
package ExerciseTest;
import java.util.*;
import java.io.*;
public class ExerciseSheet {
private static final short COLUMN_NUMBER = 5;
public static void main(String[]args) throws Throwable {
//TestGenerateOperation();//测试方法：阶段一自动生成算式，输出到文件，并再次读入
TestGenerateOperationBase();//测试方法：阶段二利用算式基生成算式,输出到文件，并再次读入
//TestJugement();//测试方法,检测练习文件生成批改文件
}
public void formattedDisplay (Exercise ex, int columns){
//调用Exercise对象将其算式按规定格式显示输出
int col = columns;
int num = 0;
while(ex.hasNext()){
col--;
num++;
System.out.printf("%-5s%-15s",num+".",ex.next());
if(col==0){
System.out.println("");
col = columns;
}
}
System.out.println("");
}
public void formattedDisplay (Exercise ex){
formattedDisplay(ex,COLUMN_NUMBER);
}
static public void TestGenerateOperation() throws Throwable {
//测试方法，利用阶段一的方式生成算式并保存到文件中
ExerciseSheet sheet = new ExerciseSheet();
Exercise exercise = new Exercise();
System.out.println("随机生成加法算式");
exercise.writeCSVAdditionEercise(50);
sheet.formattedDisplay(exercise, 5);
System.out.println("随机生成减法算式");
exercise.writeCSVSubstractEercise(50);
sheet.formattedDisplay(exercise, 5);
System.out.println("随机生成混合算式");
exercise.writeCSVBinaryEercise(50);
sheet.formattedDisplay(exercise, 5);
File aFile;
System.out.println("读入加法算式");
aFile = new File("d:/加减法练习/Addition_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
System.out.println("读入减法算式");
aFile = new File("d:/加减法练习/Substract_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
System.out.println("读入混合算式");
aFile = new File("d:/加减法练习/MixOperation_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
}
static public void TestGenerateOperationBase() throws Throwable {
//测试方法二，调用算式基生成算式，并将习题保存到文件中
ExerciseSheet sheet = new ExerciseSheet();
Exercise exercise = new Exercise();
OperationBase Base = new OperationBase();
System.out.println("随机生成加法算式");
exercise = Base.generateAdditionExercise(50);
exercise.writeCSVExercise();
sheet.formattedDisplay(exercise, 5);
System.out.println("随机生成减法算式");
exercise = Base.generateSubstractExercise(50);
exercise.writeCSVExercise();
sheet.formattedDisplay(exercise, 5);
System.out.println("随机生成混合算式");
exercise = Base.generateBinaryExercise(50);
exercise.writeCSVExercise();
sheet.formattedDisplay(exercise, 5);
File aFile;
System.out.println("Base从文件读入加法算式");
aFile = new File("d:/加减法练习/Addition_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
System.out.println("Base从文件读入减法算式");
aFile = new File("d:/加减法练习/Substract_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
System.out.println("Base从文件读入混合算式");
aFile = new File("d:/加减法练习/MixOperation_exercise_50_.csv");
exercise.readCSVExercise(aFile);
sheet.formattedDisplay(exercise);
}
static void TestJugement() throws Exception {
//测试方法三，测试批改习题功能
Exercise exercise = new Exercise();
Judgement ju = new Judgement();
System.out.println("读入加法习题和练习，批改习题生成结果文件");
File aFile = new File("d:/加减法练习/Addition_exercise_50_.csv");
exercise.readCSVExercise(aFile);
ju.Practice(exercise);
System.out.println("读入减法习题和练习，批改习题生成结果文件");
aFile = new File("d:/加减法练习/Substract_exercise_50_.csv");
exercise.readCSVExercise(aFile);
ju.Practice(exercise);
System.out.println("读入混合习题和练习，批改习题生成结果文件");
aFile = new File("d:/加减法练习/MixOperation_exercise_50_.csv");
exercise.readCSVExercise(aFile);
ju.Practice(exercise);
}
}
package ExerciseTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class Judgement{
private int correct;
private int wrong;
private int OperationCount = 0;
private int score = 0;
private String CheckingName = "";
private String PracticeName = "";
public void evaluate(Integer[] answers,Integer[] results){
//比较两个答案正误
correct = 0;
wrong = 0;
int length=answers.length<results.length?answers.length:results.length;
for(int i=0;i<length;i++)
if(answers[i]==results[i])
correct++;
else
wrong++;
wrong+=Math.abs(answers.length-results.length);
OperationCount = correct+wrong;
score = correct*2;
}
private Integer[] getResults(Exercise exercise)throws Exception{
//获得用户的答案
String Addr_Name = exercise.Addr+PracticeName;
File anExerciseFile = new File(Addr_Name);
System.out.println("已经取得"+Addr_Name+"中练习的答案");
ArrayList<Integer> opResults=new ArrayList <Integer> ();
FileInputStream in = new FileInputStream(anExerciseFile);
int b = 0;
String eqString="";
while(b!=-1){
b = in.read();
if((char)b==','||(char)b=='\r'){
opResults.add(Integer.valueOf(eqString));
eqString="";
}else if((char)b!='\r'&&(char)b!='\n')
eqString+=(char)b;
}
in.close();
Integer[] bb=new Integer[opResults.size()];
return opResults.toArray(bb);
}
private Integer[] getAnswers(Exercise exercise)throws Exception{
//获得正确答案
ArrayList<Integer>opAnswer = new ArrayList<Integer>();
while(exercise.hasNext()) {
//System.out.println(exercise.next());
opAnswer.add(exercise.next().getvalue());
}
Integer[]bb = new Integer[opAnswer.size()];
return opAnswer.toArray(bb);
}
public void writeCSVReport(File aReportFile) throws IOException{
//传入一个文件，将批改结果输出到该文件中
OperationCount = correct+wrong;//算式数量
String str;
str = "答案:"+ CheckingName;
FileWriter FW = new FileWriter(aReportFile,false);
FW.write(str+",\r\n");
str = "答案总数:"+OperationCount;
FW.write(str+",\r\n");
str = "正确:"+correct;
FW.write(str+",\r\n");
str = "错误:"+wrong;
FW.write(str+",\r\n");
str = "得分:"+score;
FW.write(str+",\r\n");
System.out.println("批改文件已生成");
FW.close();
}
public void Practice(Exercise anExercise) throws Exception {
//传入一个习题对象，并查找目录下的练习文件，然后进行批改,生成文件
getAllName(anExercise.FileName);
Integer[]Results = getResults(anExercise);
Integer[]Answers = getAnswers(anExercise);
evaluate(Answers,Results);
String Addr_Name = anExercise.Addr+CheckingName;
File file = new File(Addr_Name);
if(!file.exists())
file.createNewFile();
writeCSVReport(file);
}
public void getAllName(String Name){
//分解习题文件名称，便于找到练习文件名称和生成批改文件名称
String type,count;
int a,b,c;
a = Name.indexOf("_");
b = Name.indexOf("_",a+1);
c = Name.indexOf("_",b+1);
type = Name.substring(0,a);
count = Name.substring(b+1,c);
CheckingName = type+"_checking_"+count+"_.csv";
PracticeName = type+"_practice_"+count+"_.csv";
}
}
package ExerciseTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
public class OperationBase{//算式基类
static final int UPPER = 100;
private BinaryOperation[][]AdditionBase;//加法算式基
private BinaryOperation[][]SubstractBase;//减法算式基
public void displayBase(BinaryOperation[][] base) {
//测试方法，显示传进来的算式基的所有算式
for(BinaryOperation[]ba:base) {
for(BinaryOperation aa:ba) {
if(aa!=null)
System.out.print(aa.toString()+'\t');
}
System.out.println();
}
}
public Exercise generationExercise(int count, BinaryOperation[][] Base) {
//传入算式基，该算式基可以是加法算式基也可以是减法算式基，根据这个算式基随机生成算式并返回习题对象
Exercise anExercise = new Exercise();
BinaryOperation anOperation;
Random random = new Random();
int i, j;
while(count>0) {
do {
i = random.nextInt(UPPER+1);
j = random.nextInt(UPPER+1);
anOperation = Base[i][j];
}while(anOperation==null||anExercise.contains(anOperation));
anExercise.Add(anOperation);
count--;
}
return anExercise;
}
public Exercise generationExercise(int count,BinaryOperation[][]AddBase,BinaryOperation[][]SubBase) {
//传入两个算式基，既加法和减法算式基，根据这两个算式基随机生成混合算式并返回习题对象
Exercise anExercise = new Exercise();
BinaryOperation anOperation;
Random random = new Random();
int i, j, ran;
while(count>0) {
ran = random.nextInt(2);
switch(ran) {
case 0:
do {
i = random.nextInt(UPPER+1);
j = random.nextInt(UPPER+1);
anOperation = AddBase[i][j];
}while(anOperation==null||anExercise.contains(anOperation));
anExercise.Add(anOperation);
count--;
break;
case 1:
do {
i = random.nextInt(UPPER+1);
j = random.nextInt(UPPER+1);
anOperation = SubBase[i][j];
}while(anOperation==null||anExercise.contains(anOperation));
anExercise.Add(anOperation);
count--;
break;
}
}
return anExercise;
}
//以下三个方法被直接调用，返回一个习题，并生成文件
public Exercise generateAdditionExercise(int count) {
//生成加法习题
Exercise exercise;
exercise = generationExercise(count,AdditionBase);
exercise.FileName = "Addition_exercise_"+count+"_";
return exercise;
}
public Exercise generateSubstractExercise(int count) {
//生成减法习题
Exercise exercise;
exercise = generationExercise(count,SubstractBase);
exercise.FileName = "Substract_exercise_"+count+"_";
return exercise;
}
public Exercise generateBinaryExercise(int count) {
//生成加法习题
Exercise exercise;
exercise = generationExercise(count,AdditionBase,SubstractBase);
exercise.FileName = "MixOperation_exercise_"+count+"_";
return exercise;
}
public OperationBase() throws Throwable {
//构造函数，算式基对象实例化就判断算式基文件是否存在，若存在则直接读入，若不存在就生成
File aFile = new File("d:/加减法练习/AdditionOperationBase.csv");
File bFile = new File("d:/加减法练习/SubstractOperationBase.csv");
if(aFile.exists()&&bFile.exists()) {
readOperationBase(aFile, bFile);
System.out.println("已从文件读入算式基");
}
else {
writeOperationBase();
System.out.println("已将算式基写入文件");
}
}
public void readOperationBase(File aFile,File bFile) throws IOException {
//读入算式基
FileInputStream fisa = new FileInputStream(aFile);
FileInputStream fisb = new FileInputStream(bFile);
AdditionBase = new BinaryOperation[UPPER+1][UPPER+1];
SubstractBase = new BinaryOperation[UPPER+1][UPPER+1];
BinaryOperation op;
String eqString = "";
int b ;
for(int i = 0;i<=UPPER;i++) {
for(int j = 0;j<=UPPER-i;j++) {
while(true) {
b = fisa.read();
if(b=='\r'||b=='\n')
continue;
if(b==',')
break;
else
eqString+=(char)b;
}
op = Exercise.AddSubOperation(eqString);
AdditionBase[i][j] = op;
eqString = "";
}
}
for(int i = 0;i<=UPPER;i++) {
for(int j = 0;j<=i;j++) {
while(true) {
b = fisb.read();
if(b=='\r'||b=='\n')
continue;
if(b==',')
break;
else
eqString+=(char)b;
}
op = Exercise.AddSubOperation(eqString);
SubstractBase[i][j] = op;
eqString = "";
}
}
fisa.close();
fisb.close();
}
public void writeOperationBase() throws Throwable {
//生成算式基文件
AdditionBase = new BinaryOperation[UPPER+1][UPPER+1];
SubstractBase = new BinaryOperation[UPPER+1][UPPER+1];
BinaryOperation op;
File aFile = new File("d:/加减法练习/AdditionOperationBase.csv");
File bFile = new File("d:/加减法练习/SubstractOperationBase.csv");
if(!aFile.exists())
aFile.createNewFile();
FileWriter FW = new FileWriter(aFile,false);
for(int i = 0;i<=UPPER;i++){
for(int j = 0;j<=UPPER-i;j++) {
op = new AdditionOperation();
op.insert(i, j);
AdditionBase[i][j] = op;
FW.write(op.toString());
FW.write(",");
}
FW.write("\r\n");
}
FW.close();
op = new SubstractOperation();
if(!bFile.exists())
bFile.createNewFile();
FW = new FileWriter(bFile,false);
for(int i = 0;i<=UPPER;i++){
for(int j = 0;j<=i;j++) {
op = new SubstractOperation();
op.insert(i, j);
SubstractBase[i][j] = op;
FW.write(op.toString());
FW.write(",");
}
FW.write("\r\n");
}
FW.close();
displayBase(AdditionBase);
displayBase(SubstractBase);
}
}
package GUITest;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import javax.swing.GroupLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.GroupLayout.Alignment;
import javax.swing.border.EmptyBorder;
import ExerciseTest.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class PracticeGui extends JFrame {
private static final long serialVersionUID = 6478286329988994564L;
private JPanel contentPane;
/**
* Launch the application.
*/
static final int WINDOW_WIDTH = 600;
static final int WINDOW_HEIGHT = 500;
static final int OP_AMOUNT = 20;
static final int OP_COLUMN = 5;
static final int OP_WIDTH = 65;
static final int ANSWER_WIDTH = 35;
static final int COMPONET_HEIGHT = 25;
static final int STAT_WIDTH = 200;
static final int STAT_HEIGHT = 100;
private JTextField [] tfOp;
private JTextField [] tfAns;
private JTextArea taStat;
private Exercise exercises;
private int correctAmount;
private int wrongAmount;
private double accuracy;
private double errorrate;
private JButton btnNewButton;
private JButton btnNewButton_1;
private void judge() {
BinaryOperation op;
correctAmount = wrongAmount = 0;
accuracy = errorrate = 0;
for (int i = 0; i < OP_AMOUNT; i++) {
op = exercises.getOperation(i);
String result = String.valueOf(op.getvalue());
String answer = tfAns[i].getText().trim();
if (result.contentEquals(answer)) {
tfAns[i].setBackground(Color.GREEN);
correctAmount++;
}
else {
tfAns[i].setBackground(Color.RED);
wrongAmount++;
}
}
accuracy = (correctAmount * 1.0 / OP_AMOUNT * 1.0) * 100.0;
errorrate = (wrongAmount * 1.0 / OP_AMOUNT * 1.0) * 100.0;
String ac = String.format("%.2f", accuracy);
ac += '%';
String er = String.format("%.2f", errorrate);
er += '%';
taStat.setText("统计信息：\n\n" + "总题数： " + OP_AMOUNT
+ " 正确题数 ：" + correctAmount + " 错误题数： " + wrongAmount + '\n'
+ " 正确率： " + ac + " 错误率： " + er);
}
private void initExerciseComponets() {
exercises = new Exercise();
exercises.generateAdditionExercise(OP_AMOUNT);
tfOp = new JTextField[OP_AMOUNT];
tfAns = new JTextField[OP_AMOUNT];
for (int i = 0; i < OP_AMOUNT; i++) {
tfOp[i] = new JTextField();
tfOp[i].setBounds(20 + (i % OP_COLUMN) * (OP_WIDTH + ANSWER_WIDTH + 5),
20 + (i / OP_COLUMN) * (COMPONET_HEIGHT + 10),
OP_WIDTH,
COMPONET_HEIGHT);
tfOp[i].setHorizontalAlignment(JTextField.RIGHT);
tfOp[i].setEditable(false);
contentPane.add(tfOp[i]);
tfAns[i] = new JTextField();
tfAns[i].setBounds(20 + (i % OP_COLUMN) * (OP_WIDTH + ANSWER_WIDTH + 5) + OP_WIDTH,
20 + (i / OP_COLUMN) * (COMPONET_HEIGHT + 10),
ANSWER_WIDTH,
COMPONET_HEIGHT);
tfAns[i].setEditable(true);
contentPane.add(tfAns[i]);
}
//按钮与统计信息文本域
JButton button = new JButton("\u91CD\u65B0\u751F\u6210\u9898\u76EE");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
exercises.generateAdditionExercise(OP_AMOUNT);
updateExerciseComponets();
}
});
JButton button_1 = new JButton("\u63D0\u4EA4\u7B54\u6848");
button_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
judge();
}
});
taStat = new JTextArea();
btnNewButton = new JButton("New button");
contentPane.add(btnNewButton, BorderLayout.WEST);
btnNewButton_1 = new JButton("New button");
contentPane.add(btnNewButton_1, BorderLayout.EAST);
GroupLayout gl_contentPane = new GroupLayout(contentPane);
gl_contentPane.setHorizontalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGap(46)
.addGroup(gl_contentPane.createParallelGroup(Alignment.TRAILING, false)
.addComponent(button_1, Alignment.LEADING, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(button, Alignment.LEADING, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addGap(47)
.addComponent(taStat, GroupLayout.PREFERRED_SIZE, 330, GroupLayout.PREFERRED_SIZE)
.addContainerGap(246, Short.MAX_VALUE))
);
gl_contentPane.setVerticalGroup(
gl_contentPane.createParallelGroup(Alignment.TRAILING)
.addGroup(gl_contentPane.createSequentialGroup()
.addContainerGap(290, Short.MAX_VALUE)
.addGroup(gl_contentPane.createParallelGroup(Alignment.TRAILING)
.addComponent(taStat, GroupLayout.PREFERRED_SIZE, 97, GroupLayout.PREFERRED_SIZE)
.addGroup(gl_contentPane.createSequentialGroup()
.addComponent(button)
.addGap(36)
.addComponent(button_1)))
.addGap(64))
);
contentPane.setLayout(gl_contentPane);
}
private void updateExerciseComponets() {
BinaryOperation op;
for (int i = 0; i < OP_AMOUNT; i++) {
op = exercises.getOperation(i);
tfOp[i].setText(op.toString());
tfAns[i].setBackground(Color.WHITE);
tfAns[i].setText(" ");
}
String ac = String.format("%.2f", accuracy);
ac += '%';
String er = String.format("%.2f", errorrate);
er += '%';
taStat.setText("统计信息：\n\n" + "总题数： " + OP_AMOUNT
+ " 正确题数 ：" + correctAmount + " 错误题数： " + wrongAmount + '\n'
+ " 正确率： " + ac + " 错误率： " + er);
taStat.setEditable(false);
}
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
PracticeGui frame = new PracticeGui();
frame.setTitle("100以内的口算练习程序");
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public PracticeGui() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, WINDOW_WIDTH, WINDOW_HEIGHT);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(new BorderLayout(0, 0));
setContentPane(contentPane);
initExerciseComponets();
updateExerciseComponets();
}
}
package GUITest;
import java.awt.Color;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import ExerciseTest.BinaryOperation;
import ExerciseTest.Exercise;
import ExerciseTest.ExerciseIOException;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.JMenuBar;
import javax.swing.JButton;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JToolBar;
import javax.swing.LayoutStyle.ComponentPlacement;
import javax.swing.JTextField;
import java.awt.event.ActionListener;
import java.io.File;
import java.awt.event.ActionEvent;
import javax.swing.JLabel;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFileChooser;
public class PracticeGui2<Answers> extends JFrame {
private static final long serialVersionUID = -8069047189470765958L;
private JPanel contentPane;
private boolean submitted;//确定当前位置的题目是不是已经写了
static final int WINDOW_WIDTH = 600;
static final int WINDOW_HEIGHT = 500;
static final int OP_AMOUNT = 20;
static final int OP_COLUMN = 5;
static final int OP_WIDTH = 65;
static final int ANSWER_WIDTH = 35;
static final int COMPONET_HEIGHT = 25;
static final int STAT_WIDTH = 200;
static final int STAT_HEIGHT = 100;
//设置窗口大小和相关变量的位置
private JTextField [] tfOp;//放算式的文本域
private JTextField [] tfAns;//放答案的框
private Exercise exercise;
private int totalAmount;
private int correctAmount;
private int wrongAmount;
private double accuracy;
private double errorrate;
private int currentPage;
private int totalPages;
JToolBar toolBar = new JToolBar(); //导入
JToolBar toolBar_1 = new JToolBar(); //题目
JToolBar toolBar_2 = new JToolBar(); // 翻页
//三个工具栏，对应三个功能组合
JButton button_7 = new JButton("\u4E0A\u4E00\u9875"); //上一页
JButton button_8 = new JButton("\u4E0B\u4E00\u9875"); //下一页
JMenuItem menuItem_5 = new JMenuItem("\u4E0A\u4E00\u9875"); //菜单上一页
JMenuItem menuItem_6 = new JMenuItem("\u4E0B\u4E00\u9875"); //菜单下一页
JLabel label = new JLabel("");
JLabel lblNewLabel = new JLabel("New label"); //当前页数
JLabel lblNewLabel_1 = new JLabel("New label"); //总页数
JLabel lblNewLabel_3 = new JLabel("New label"); //状态栏
JLabel lblNewLabel_4 = new JLabel("New label"); //答案状态栏
private void reachBegin() {
this.button_7.setEnabled(false);
this.menuItem_5 .setEnabled(false);
//一开始没有上一页，禁止点击上一页
}
private void reachEnd() {
this.button_8.setEnabled(false);
this.menuItem_6 .setEnabled(false);
//到达最后一页后没有下一页，禁止点击下一页
}
private void leaveBegin() {
this.button_7.setEnabled(true);
this.menuItem_5 .setEnabled(true);
}
private void leaveEnd() {
this.button_8.setEnabled(true);
this.menuItem_6 .setEnabled(true);
}
//这两个方法用于离开最后一页或者离开第一页的时候，可以点击第一页或者最后一页，要解开禁止
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
PracticeGui2 frame = new PracticeGui2();//定义窗口对象
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
private void initComponets() {
//加入一定数目的算式和答案
this.submitted = false;
exercise = new Exercise();
exercise.generateAdditionExercise(OP_AMOUNT);
this.currentPage = 1;
this.totalPages = 1;
this.reachBegin();
this.reachEnd();
tfOp = new JTextField[OP_AMOUNT];
tfAns = new JTextField[OP_AMOUNT];
//生成对应数目的算式位置和答案位置
for (int i = 0; i < OP_AMOUNT; i++) {
//循环加入算式和答案，配对加入
tfOp[i] = new JTextField();
tfOp[i].setBounds(20 + (i % OP_COLUMN) * (OP_WIDTH + ANSWER_WIDTH + 5),
50 + (i / OP_COLUMN) * (COMPONET_HEIGHT + 10),
OP_WIDTH,COMPONET_HEIGHT);
//设置算式框的位置和大小，位置遵循一定的规律
tfOp[i].setHorizontalAlignment(JTextField.RIGHT);
//设置算式框里面的算式为右对齐
tfOp[i].setEditable(false);//算式位置是不可更改的
contentPane.add(tfOp[i]);
tfAns[i] = new JTextField();
tfAns[i].setBounds(20 + (i % OP_COLUMN) * (OP_WIDTH + ANSWER_WIDTH + 5) + OP_WIDTH,
50 + (i / OP_COLUMN) * (COMPONET_HEIGHT + 10),
ANSWER_WIDTH,
COMPONET_HEIGHT);
tfAns[i].setEditable(true);
contentPane.add(tfAns[i]);
//答案框的加入和算式框相同
}
}
private void updateComponets() {
//显示题目和答案框以及其对应格式
this.totalPages = exercise.length() / OP_AMOUNT;
this.lblNewLabel.setText("第 " + String.valueOf(this.currentPage) + " 页");
this.lblNewLabel_1.setText("共 " + String.valueOf(this.totalPages) + " 页");
//设置页数标签
if (this.currentPage == 1)
this.reachBegin();
else
this.leaveBegin();
if (this.currentPage == this.totalPages)
this.reachEnd();
else
this.leaveEnd();
//设置当前页到第一页或者最后一页的时候点击权限
BinaryOperation op;
for (int i = 0; i < OP_AMOUNT; i++) {
op = exercise.getOperation((currentPage - 1) * OP_AMOUNT + i);
tfOp[i].setText(op.toString());
//获得已经生成的算式中的算式并加入到文本域中
if(!submitted) {
tfAns[i].setBackground(Color.WHITE);
//没写东西的时候答案框设置为白色
}
else {
if(exercise.getJudgement((currentPage - 1) * OP_AMOUNT + i))
tfAns[i].setBackground(Color.GREEN);
else
tfAns[i].setBackground(Color.RED);
//已经提交了的话就根据答案是否正确，将答案框设置为不同的颜色
}
tfAns[i].setText(exercise.getAnswer((currentPage - 1) * OP_AMOUNT + i));
}
String s = new String();
if(!submitted ) {
s = "点击【提交】后可获取";
}
else {
//计算正确率等一系列量
totalAmount = exercise.length();
correctAmount = exercise.Correct();
wrongAmount = totalAmount - correctAmount;
accuracy = (correctAmount * 1.0 / totalAmount * 1.0) * 100.0;
errorrate = (wrongAmount * 1.0 / totalAmount * 1.0) * 100.0;
String co = String.format("%d", correctAmount);
String wr = String.format("%d", wrongAmount);
String ac = String.format("%.2f", accuracy);
ac += '%';
String er = String.format("%.2f", errorrate);
er += '%';
s = "正确题数 ： " + co + " " + "错误题数 ： " + wr + " " +
"正确率 : " + ac + " " + "错误率 : " + er;
}
lblNewLabel_3.setText("状态： "
+ "题目类型 - " + exercise.getExerciseType()
+ " "
+ "题目数量 - " + exercise.length());
lblNewLabel_4.setText(s);
}
private void impExercise() {
//导入题目
JFileChooser jfc = new JFileChooser();//新建一个文件选择器
jfc.showOpenDialog(null);//设置参数的值可以改变文件选择器在屏幕上的弹出位置
File file = jfc.getSelectedFile();
try {
exercise = Exercise.loadObject(file.getAbsolutePath());
JOptionPane.showMessageDialog(null, "导入题目成功！"
,"提示",JOptionPane.INFORMATION_MESSAGE);
this.submitted = false;
updateComponets();
}catch(NullPointerException npe) {
}catch(ExerciseIOException e) {
JOptionPane.showMessageDialog(null, "导入题目失败，可能是因为选择了错误的文件",
"错误",JOptionPane.ERROR_MESSAGE);
}
}
private void expExercise() {
//导出题目
JFileChooser jfc = new JFileChooser();
jfc.showOpenDialog(null);
File file = jfc.getSelectedFile();
try {
exercise.saveObject(file.getAbsolutePath(), exercise);
//把这一道题目导出到文件里面
JOptionPane.showMessageDialog(null, "导出题目成功！"
,"提示",JOptionPane.INFORMATION_MESSAGE);
}catch(NullPointerException npe) {
}catch(ExerciseIOException e) {
JOptionPane.showMessageDialog(null, "导出题目失败，可能是因为选择了错误的文件",
"错误",JOptionPane.ERROR_MESSAGE);
}
}
//导入导出题目用的都是JFileChooser对象，用这个对象来获得目标路径，之后用file对象进行导入导出
private void prePage() { //上翻一页
getAnswers(this.currentPage);
//上下翻页的时候，先把当前页的内容存下来
if(this.currentPage == this.totalPages)
this.leaveEnd();
if(--currentPage == 1)
this.reachBegin();
//调整页数之后对页数上下翻页的限制
this.lblNewLabel.setText(String.valueOf(currentPage));
updateComponets();
}
private void nextPage() { //下翻一页
getAnswers(this.currentPage);
if(this.currentPage == this.totalPages)
this.leaveEnd();
if(++currentPage == totalPages)
this.reachEnd();
this.lblNewLabel.setText(String.valueOf(currentPage));
updateComponets();
}
private void getAnswers(int pageIndex) { //获取答案
for (int i = 0; i < OP_AMOUNT; i++) {
exercise.setAnswer((pageIndex - 1) * OP_AMOUNT + i, tfAns[i].getText());
}
}
private void generateExercise() { //重新生成题目
int length = exercise.length();
exercise.generateWithFormerType(length);
//通过两次调用方法，更新题目对象，实现重新生成题目的功能
updateComponets();
}
private void judgeAnswer() {
this.submitted = true;
getAnswers(this.currentPage);
updateComponets();//把目前做的题目进行批改，更新答案框的颜色
}
private void clearAnswers() {
exercise.clearAnswers();
this.submitted = false;
updateComponets();
//把答案清空，提交状态改为未提交
}
public PracticeGui2() {
//可视化窗口编辑GUI界面，添加对应的动作监听
setTitle("100\u4EE5\u5185\u7684\u53E3\u7B97\u7EC3\u4E60\u7A0B\u5E8F");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 570, 376);
JMenuBar menuBar = new JMenuBar();
setJMenuBar(menuBar);
JMenu menu = new JMenu("\u6587\u4EF6");
menuBar.add(menu);
JMenuItem menuItem = new JMenuItem("\u5BFC\u5165");
menu.add(menuItem);
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
impExercise();
}
});
JMenuItem menuItem_1 = new JMenuItem("\u5BFC\u51FA");
menu.add(menuItem_1);
menuItem_1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
expExercise();
}
});
JMenu menu_1 = new JMenu("\u9898\u76EE\u8BBE\u7F6E");
menuBar.add(menu_1);
JMenu menuItem_7 = new JMenu("\u6839\u636E\u7C7B\u578B\u751F\u6210");
menu_1.add(menuItem_7);
JCheckBoxMenuItem chckbxmntmadd = new JCheckBoxMenuItem("\u52A0\u6CD5\u9898\u76EE");
menuItem_7.add(chckbxmntmadd);
chckbxmntmadd.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int length = exercise.length();
exercise.generateAdditionExercise(length);
updateComponets();
}
});
JCheckBoxMenuItem chckbxmntmsub = new JCheckBoxMenuItem("\u51CF\u6CD5\u9898\u76EE");
menuItem_7.add(chckbxmntmsub);
chckbxmntmsub.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int length = exercise.length();
exercise.generateSubstractExercise(length);
updateComponets();
}
});
JCheckBoxMenuItem chckbxmntmas = new JCheckBoxMenuItem("\u52A0\u51CF\u6DF7\u5408");
menuItem_7.add(chckbxmntmas);
chckbxmntmas.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int length = exercise.length();
exercise.generateBinaryExercise(length);
updateComponets();
}
});
JMenu menuItem_8 = new JMenu("\u6839\u636E\u6570\u91CF\u751F\u6210");
menu_1.add(menuItem_8);
JCheckBoxMenuItem checkBoxMenuItem_3 = new JCheckBoxMenuItem("20");
menuItem_8.add(checkBoxMenuItem_3);
checkBoxMenuItem_3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
exercise.generateWithFormerType(20);
updateComponets();
}
});
JCheckBoxMenuItem checkBoxMenuItem_4 = new JCheckBoxMenuItem("40");
menuItem_8.add(checkBoxMenuItem_4);
checkBoxMenuItem_4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
exercise.generateWithFormerType(40);
updateComponets();
}
});
JCheckBoxMenuItem checkBoxMenuItem_5 = new JCheckBoxMenuItem("100");
menuItem_8.add(checkBoxMenuItem_5);
checkBoxMenuItem_5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
exercise.generateWithFormerType(100);
updateComponets();
}
});
JMenu menu_2 = new JMenu("\u9898\u76EE\u64CD\u4F5C");
menuBar.add(menu_2);
JMenuItem menuItem_2 = new JMenuItem("\u91CD\u65B0\u751F\u6210");
menu_2.add(menuItem_2);
menuItem_2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
generateExercise();
clearAnswers();
}
});
JMenuItem menuItem_3 = new JMenuItem("\u6E05\u7A7A");
menu_2.add(menuItem_3);
menuItem_3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
clearAnswers();
}
});
JMenuItem menuItem_4 = new JMenuItem("\u63D0\u4EA4");
menu_2.add(menuItem_4);
menuItem_4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
judgeAnswer();
}
});
JMenu menu_3 = new JMenu("\u67E5\u770B");
menuBar.add(menu_3);
menu_3.add(menuItem_5);
menuItem_5.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
prePage();
}
});
menu_3.add(menuItem_6);
menuItem_6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
nextPage();
}
});
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
JLabel lblNewLabel_2 = new JLabel("New label");
lblNewLabel_2.setText("------------------------------------------"
+ "------------------------------------------"
+ "-----------------------------------------------------");
GroupLayout gl_contentPane = new GroupLayout(contentPane);
gl_contentPane.setHorizontalGroup(
gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGroup(gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addComponent(toolBar, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(toolBar_1, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(toolBar_2, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addGroup(gl_contentPane.createSequentialGroup()
.addGap(137)
.addGroup(gl_contentPane.createParallelGroup(Alignment.LEADING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGap(63)
.addComponent(lblNewLabel)
.addGap(42)
.addComponent(lblNewLabel_1))
.addComponent(label)))
.addComponent(lblNewLabel_2)
.addGroup(gl_contentPane.createSequentialGroup()
.addContainerGap()
.addComponent(lblNewLabel_3))
.addGroup(gl_contentPane.createSequentialGroup()
.addContainerGap()
.addComponent(lblNewLabel_4)))
.addContainerGap(GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
gl_contentPane.setVerticalGroup(
gl_contentPane.createParallelGroup(Alignment.TRAILING)
.addGroup(gl_contentPane.createSequentialGroup()
.addGroup(gl_contentPane.createParallelGroup(Alignment.LEADING)
.addComponent(toolBar, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
.addComponent(toolBar_1, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
.addComponent(toolBar_2, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
.addPreferredGap(ComponentPlacement.RELATED, 169, Short.MAX_VALUE)
.addComponent(label)
.addGap(13)
.addGroup(gl_contentPane.createParallelGroup(Alignment.BASELINE)
.addComponent(lblNewLabel_1)
.addComponent(lblNewLabel))
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(lblNewLabel_2)
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(lblNewLabel_3)
.addPreferredGap(ComponentPlacement.UNRELATED)
.addComponent(lblNewLabel_4)
.addGap(19))
);
button_7.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
prePage();
}
});
toolBar_2.add(button_7);
button_8.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
nextPage();
}
});
toolBar_2.add(button_8);
JButton button_4 = new JButton("\u91CD\u65B0\u751F\u6210");
button_4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
generateExercise();
clearAnswers();
}
});
toolBar_1.add(button_4);
JButton button = new JButton("\u6E05\u7A7A");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
clearAnswers();
}
});
toolBar_1.add(button);
JButton button_6 = new JButton("\u63D0\u4EA4");
button_6.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
judgeAnswer();
}
});
toolBar_1.add(button_6);
JButton button_2 = new JButton("\u5BFC\u5165");
button_2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
impExercise();
}
});
toolBar.add(button_2);
JButton button_3 = new JButton("\u5BFC\u51FA");
button_3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
expExercise();
}
});
toolBar.add(button_3);
contentPane.setLayout(gl_contentPane);
initComponets();
updateComponets();
}
}
2265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
