自动生成数学题型一 (框架Struts2) 题型如（a+b=c）

1. 加减乘除

1.1 随机生成制定范围的整数

 /**
      * 随机产生一个被限定范围的整数
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return 返回一个 num1 到num2 之间的随机整数数值,且num1<num2
      *
      */

     public static int generate(int num1, int num2) {
         boolean i = num1 <= num2;
         int k = -1;
         // 如果i为true，即num1<num2,返回num1到num2之间的值，否则返回-1;
         if (i == true)
             k = (int) (Math.random() * (num2 - num1 + 1)) + num1;
         return k;

     }

1.2 加法运算

 /**
      * 加法运算，生成加数、被加数和和组成的数组
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return 返回数组add，包括加数，被加数，和随机生成的第一个数与第二个整数的和， 此两个整数在num1 和num2之间
      */

     public static double[] addition(int num1, int num2) {
         int first = generate(num1, num2);// 随机生成的第一个整数(加数)
         int secound = generate(num1, num2);// 随机生成的第二个整数(被家数)
         int result = first + secound;// 第一个整数与第二个整数相加得到的整数
         double[] add = new double[] { first, secound, result, 0, 0 };
         return add;
     }

1.3 减法运算

 /**
      * 减法运算，生成减数、被减数和差组成的数组
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return 返回数组sub[],包括减数，被减数，和第二个随机生成的数值减去第一个随机生成的数值的差
      *         (第一个生成数值大于第二个生成数值，此两个整数在num1 和num2之间)
      *
      */
     public static double[] subtraction(int num1, int num2) {
         int first = generate(num1, num2);// 随机生成的第一个数(减数)
         int secound = generate(first, num2);// 随机生成的第二个数(被减数)
         int result = secound - first;// 第二个随机生成的数值减去第一个随机生成的数值的值
         double[] sub = new double[] { secound, first, result, 0, 1 };
         return sub;
     }

1.4 乘法运算

 /**
      * 乘法运算，生成乘数、被乘数和积组成的数组
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return 返回数组，包括乘数，被乘数和随机生成的数的积此(此两个整数在num1 和num2之间
      */

     public static double[] multiplication(int num1, int num2) {
         int first = generate(num1, num2);// 随机生成的第一个整数(乘数)
         int secound = generate(num1, num2);// 随机生成的第二个整数(被乘数)
         int result = first * secound;// 第一个整数与第二个整数相加得到的整数
         double[] mult = new double[] { first, secound, result, 0, 3 };
         return mult;

     }

1.5 除法运算

 /**
      * 除法运算，返回除数、被除数和商数组成的数组
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return
      */

     public static double[] division2(int num1, int num2) {
         double first = generate(num1, num2);// 随机生成的第一个整数(除数)
         double secound = generate((int)first, num2);// 随机生成的第二个整数(被除数)
         double result = secound / first;
         double[] div2 = new double[] { secound, first, result, 0, 4 };
         return div2;
     }

1.6 求余运算

 /**
      * 除法求余数运算，生成除数、被除数、积和余数组成的数组
      *
      * @param num1
      *            定义起始范围 num1
      * @param num2
      *            定义终止范围 num2
      * @return 返回数组div,包阔除数，被除数,余数和随机生成的数两个数的商(随机生成的数第一个大于第二个数)
      */
     public static double[] division(int num1, int num2) {

         int first = generate(num1, num2);// 随机生成的第一个整数(除数)
         int secound = generate(first, num2);// 随机生成的第二个整数(被除数)
         int result = secound / first;
         int remainder = secound % first;
16         double[] div = new double[] { secound, first, result, remainder, 5 };
17         return div;
18     }

1.7 加减乘除四种随机生成

/**
     * 随机生成加、减、乘、除四种的数组
     *
     * @param num5
     *            定义起始范围 num5
     * @param num6
     *            定义终止范围 num6
     * @return 随机生成的一组数组
     */

    public static double[] fourExercise(int num5, int num6) {
        final int num1 = 0;
        final int num2 = 1;
        final int num3 = 2;
        final int num4 = 3;
        int num = generate(num1, num4);
        switch (num) {
        case num1:
            double[] sub = subtraction(num5, num6);
            return sub;
        case num2:
            double[] add = addition(num5, num6);
            return add;
        case num3:
            double[] mult = multiplication(num5, num6);
            return mult;
        case num4:
            double[] div = division2(num5, num6);
            return div;
        default:
            break;
        }
        return null;
    }

2.判断处理

2.1 根据题目类型和数量生成题目

 /**
      * judge方法，处理参数，并形成新的list集合的对象
      *
      * @param exerciseNumber
      *            习题数量
      * @param exerciseType
      *            习题种类(加减乘除)
      * @param num5
      *            起始数值
      * @param num6
      *            结束数值
      * @return 返回list集合
      */

     public List<Number3> judge(int exerciseNumber, int exerciseType, int num5, int num6) {
         final int num1 = 0;
         final int num2 = 1;
         final int num3 = 2;
         final int num4 = 3;
         final int num7 = 4;
         final int num8 = 5;
         List<Number3> exercise = new ArrayList<Number3>();
         Number3 number = null;
         switch (exerciseType) {
         case num1:
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] sub = subtraction(num5, num6);
                 number = new Number3();
                 number.setNum1((int) sub[0]);
                 number.setNum2((int) sub[1]);
                 number.setNum3(String.format("%.0f", sub[2]));
                 number.setNumType("-");
                 number.setSymbol("=");
                 exercise.add(number);
             }
             return exercise;
         case num2:
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] add = addition(num5, num6);
                 number = new Number3();
                 number.setNum1((int) add[0]);
                 number.setNum2((int) add[1]);
                 number.setNum3(String.format("%.0f", add[2]));
                 number.setNumType("+");
                 number.setSymbol("=");
                 exercise.add(number);
             }
             return exercise;
         case num3:
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] mult = multiplication(num5, num6);
                 number = new Number3();
                 number.setNum1((int) mult[0]);
                 number.setNum2((int) mult[1]);
                 number.setNum3(String.format("%.0f", mult[2]));
                 number.setNumType("*");
                 number.setSymbol("=");
                 exercise.add(number);
                 System.out.println(exercise);
             }
             return exercise;
         case num4:
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] div = division(num5, num6);
                 number = new Number3();
                 number.setNum1((int) div[0]);
                 number.setNum2((int) div[1]);
                 number.setNum3(String.format("%.0f", div[2]));
                 number.setNum4(String.format("%.0f", div[3]));
                 number.setNumType("/");
                 number.setSymbol("=");
                 exercise.add(number);
             }
             return exercise;
         case num7:
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] fourexercise = fourExercise(num5, num6);
                 number = new Number3();
                 System.out.println(exerciseType + "exerciseType");
                 if (fourexercise[4] == 0) {
                     number.setNum1((int) fourexercise[0]);
                     number.setNum2((int) fourexercise[1]);
                     number.setNum3(String.format("%.0f", fourexercise[2]));
                     number.setNumType("-");
                     number.setSymbol("=");
                 } else if (fourexercise[4] == 1) {
                     number.setNum1((int) fourexercise[0]);
                     number.setNum2((int) fourexercise[1]);
                     number.setNum3(String.format("%.0f", fourexercise[2]));
                     number.setNumType("+");
                     number.setSymbol("=");
                 } else if (fourexercise[4] == 2) {
                     number.setNum1((int) fourexercise[0]);
                     number.setNum2((int) fourexercise[1]);
                     number.setNum3(String.format("%.0f", fourexercise[2]));
                     number.setNumType("*");
                     number.setSymbol("=");
                 } else {
                     number.setNum1((int) fourexercise[0]);
                     number.setNum2((int) fourexercise[1]);
                     number.setNum3(String.format("%.6f", fourexercise[2]));
                     number.setNum4(String.format("%.6f", fourexercise[3]));
                     number.setNumType("/");
                     number.setSymbol("=");
                 }
                 exercise.add(number);
             }
             return exercise;
         case num8:
             Number3 number2 = null;
             for (int i = 0; i < exerciseNumber; i++) {
                 double[] div2 = division2(num5, num6);
                 number2 = new Number3();
                 number2.setNum1((int) div2[0]);
                 number2.setNum2((int) div2[1]);
                 number2.setNum3(String.format("%.6f", div2[2]));
                 number2.setNumType("/");
                 number2.setSymbol("=");
                 exercise.add(number2);
             }
             System.out.println(exercise);
             return exercise;
         default:
             break;
         }
         return null;
     }

2.2 实体类Number3

    public class Number3 {
        private int num1;
        private int num2;
        private String num3;
        private String num4;
        private String numType;
        private String symbol;
        .....
  　　　//此处省略set和get方法
  }

2.3 action类

 public class Exercise {
     private String exerciseType;
     private String min;
     private String max;
     private String exerciseNumber;

     ......
 　　//此处省略get和set方法

     public String execute() {
         ActionContext actioncontext = ActionContext.getContext();
         Map<String, Object> session = actioncontext.getSession();
         count cou = new count();
         List<Number3> exercise = cou.judge(Integer.valueOf(exerciseNumber), Integer.valueOf(exerciseType),
                 Integer.valueOf(min), Integer.valueOf(max));
         session.put("exercises", exercise);
         session.put("exerciseType",exerciseType);
         if (exerciseType.equals("3")) {
             return "d";
         } else {
             return "asm";
         }
     }
 }

3. 运行结果截图

3.1 初始页面

3.2用户输入题目数量和题型

3.3生成题目页面

3.4 尝试填写结果

3.5检测运行结果（检测代码会在之后）