练习5.1——四则运算 测试与封装（更新版）

主函数：

package h2;

import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.regex.Pattern;

import Excep.YichangException;
/*
 * 1.定制数量
 * 2.控制是否有乘除法
 * 3.控制数值范围
 * 4.定制真分数练习题
 * 5.校检用户输入
 * 6.输出答题正确率
 */
public class Main {
    public static int max = 10;// 控制算式个数
    public static String[] staticanser = new String[max];// 标准答案
    public static DecimalFormat decimal = new DecimalFormat("#.##");
    
    
    // 求最大公约数
    private static int calcMaxSubmultiple(int num1, int num2) {
        num1=Math.abs(num1);//防止负数时求不得最大公约数。
        num2=Math.abs(num2);
        int min = Math.min(num1, num2);
        int maxSubmultiple = 1;
        for (int i = min; i >= 1; i--) {
            if (num1 % i == 0 && num2 % i == 0)
            {
                maxSubmultiple = i;
                break;
            }
            
        }
        return maxSubmultiple;
    }
//主函数
    public static void main(String[] args)  {
        
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = new int[4];// 操作符地址
        int useno = 0;// 控制操作符
        int n = 3;// 操作数个数（随机）
        int[] num1 = new int[10];// 操作数
        char opp;// 判断是否需要乘除法
        char real;// 判断是否需要真分数的题目
        int[] cs = { 1, 100 };// 数值范围
        String[] useranser = new String[max];// 用户输入的答案
        
        
        int f = 0;// 控制输出真分数的操作符
        int count = 0;// 统计答题正确的数量
        
        int s1 = 1;// 分子通分
        int ss1 = 1;// 分子通分
        int s2 = 1;// 分母通分
        int result = 0;// 分子计算
        int gys;// 最大公约数
        int ff = 0;// 分数除法，分子为0标志位
        int fff=0;//
        String zjfz = new String();// 最简分子
        String zjfm = new String();// 最简分母
        Pattern pattern = Pattern.compile("[0-9]*"); // 限定输入算式数量输入的必须是数字

        Scanner in = new Scanner(System.in);
         //定制要求 
        System.out.print("请输入需定制的算式数量（1-20）：");// 1.定制数量
        do {
            String str = in.nextLine();
            if (pattern.matcher(str).matches()) {// 如果输入的是数字就执行
                max = Integer.parseInt(str);
                if(max<=20&&max>0)
                {
                    break;
                }
                else
                {
                    System.out.print("你输入的范围有误，请重新输入:");
                }
                
            } else {                                                                       
                System.out.print("你输入的不是数字，请重新输入:");
            }
        } while (true);

    
        System.out.print("是否需要乘除法（Y/N）:");// 2.控制乘除参数
        do {
            opp = in.next().charAt(0);
            if (opp == 'Y' || opp == 'y') {
                useno = 4;
                break;
            } else if (opp == 'N' || opp == 'n') {
                useno = 2;
                break;
            } else {
                System.out.print("输入错误，请重新输入:");
            }
        } while (true);

        System.out.print("参数范围（eg:1,100）:");// 3.控制数值范围
        String str = new String();
        int sr = 0;//判断循环结束
        in.nextLine();// 过滤掉上面.next()方面的回车。
        do {
            try {
                str = in.nextLine();
                String[] ss = new String[2];
                ss = str.split(",");
                cs[0] = Integer.valueOf(ss[0]);
                cs[1] = Integer.valueOf(ss[1]);
                sr = 1;
            } catch (Exception e) {
                System.out.print("输入格式错误，请重新输入:");
            }
        } while (sr != 1);


        System.out.print("是否增加真分数练习题（Y/N）:");// 4.真分数题目
         do {
             real = in.next().charAt(0);
             if ( real == 'Y' || real == 'y') {
                 
                 break;
             } else if ( real == 'N' || real == 'n') {
                break;
             } else {
                 System.out.print("输入错误，请重新输入:");
             }
         } while (true);

         //----------------题目-----------------------
        System.out.println();
        System.out.println("                2014-2015学年度第一单元测试卷");
        System.out
                .println("班级：             姓名：             座号：          得分：                  ");
        System.out.println();
        System.out.println("一、请认真仔细地计算下面各题。(小数请保留小数点后两位)");
        System.out.println();
        Core c1=new Core();
        for (int i = 0; i < max; i++) {

            System.out.print("(" + (i + 1) + ") ");
            n = (int) (Math.random() * 4 + 2);// 2-5个操作数
            for (int j = 0; j < n; j++) {
                num1[j] = (int) (Math.random() * (cs[1] - cs[0]) + cs[0]);// 控制随机数数值
            }
            for (int k = 0; k < n - 1; k++) {
                no[k] = (int) (Math.random() * useno + 1);// 随机产生操作符
                if(no[k]==4&&num1[k+1]==0){
                    do{
                    num1[k+1]=(int) (Math.random() * (cs[1] - cs[0]) + cs[0]);//如果除号后为0，则重新取数。
                    }while(num1[k+1]==0);
                }
            }
            for (int h = 0; h < n; h++) {
                if (h != n - 1) {
                    if(num1[h]<0)
                    {
                        System.out.print("("+num1[h]+")");
                        System.out.print(op[no[h]]);
                    }
                    else{
                    System.out.print(num1[h]);
                    System.out.print(op[no[h]]);
                    }
                } else {
                    if(num1[h]<0)
                    {
                        System.out.print("("+num1[h]+")=");
                    }
                    else
                      System.out.print(num1[h] + "=");
                }
            }
            System.out.println();
                c1.calcute(num1, op, no, n);
        }

        

        
        
        
        // 学生答题模块
        System.out.println("==================答题分割线=========================");
        for (int i = 0; i < max; i++) {
            System.out.print((i + 1) + ":");
            useranser[i]=in.next();
            if (useranser[i].equalsIgnoreCase(staticanser[i])) {
                count++;
            }
        }
        System.out.println("标准答案为：");
        for (int i = 0; i < max; i++) {
            System.out.println((i + 1) + ":" + staticanser[i]);
        }
        System.out.println("答题正确率为：" + String.valueOf(decimal.format(((float) count / (float) max) * 100))
                + "%");
        System.out.println("==================答题分割线=========================");

//真分数     
        if (real == 'Y' || real == 'y') {
            System.out.println("二、请计算下列真分数算式。（无法计算请填null）");
            System.out.println();
            for (int i = 0; i < max; i++) {
                System.out.print("(" + (i + 1) + ") ");
                for (int j = 0; j < 2; j++)// (第一个真分数)
                {
                    num1[j] = (int) (Math.random() * (cs[1] - cs[0]) + cs[0]);// 控制随机数数值
                    if (j == 1 ) {
                        while (num1[j - 1] >num1[j]||num1[j]== 0) {
                            num1[j] = (int) (Math.random() * (cs[1] - cs[0]) + cs[0]);// 控制随机数数值
                        }
                    }
                }
                for (int j = 2; j < 4; j++)// (第二个真分数)
                {
                    num1[j] = (int) (Math.random() * (cs[1] - cs[0]) + cs[0]);// 控制随机数数值
                    if (j == 3) {
                        while (num1[j - 1] >num1[j]||num1[j]== 0) {
                            num1[j] = (int) (Math.random() * (cs[1] - cs[0]) + cs[0]);// 控制随机数数值
                        }
                    }
                }

                for (int k = 0; k < 1; k++) {// 符号个数
                    no[k] = (int) (Math.random() * useno + 1);// 随机产生操作符
                }
                for (int h = 0; h < 4; h++) {// 2个真分数
                    if (h % 2 == 0)
                        System.out.print(("(" + num1[h] + "/"));
                    else if (h % 2 == 1) {
                        System.out.print(num1[h] + ")");
                        if (f < 1) {// 控制只输出一个操作符
                            System.out.print(op[no[f]]);
                            f++;
                        } else
                            System.out.println("=");

                    }
                }

                f = 0;
                //计算第二大题标准答案
                count=0;
                
            }

            // 答题模板
            System.out.println("==================答题分割线=========================");
            for (int i = 0; i < max; i++) {
                System.out.print((i + 1) + ":");
                useranser[i] = in.next();
                if (useranser[i].equals(staticanser[i])) {
                    count++;
                }
            }
            System.out.println("标准答案为：");
            for (int i = 0; i < max; i++) {
                System.out.println((i + 1) + ":" + staticanser[i]);
            }
            System.out.println("答题正确率为：" + String.valueOf(decimal.format(((float) count / (float) max) * 100))
                    + "%");
            System.out
                    .println("==================答题分割线=========================");
        }

    }
}

封装Core类实现计算功能：

package h2;

import Excep.YichangException;

public class Core {
    int sign; // 累加运算时的符号
    float left, right;// 保存蹭结果
    int i = 0;
    float result;

    public void calcute(int[] num1, char[] op, int[] no, int n)
             {
        // 一个算式中的所有数字num1，符号op,随机产生的符号下标no,随机产生的算式操作数个数n.
        // // 计算第一大题答案
            for (int h = 0; h < n - 1; h++) {
                if ((no[h] == 4) && (num1[h + 1] == 0)) {
                    throw new ArithmeticException();
                }
            }
            left = 0;
            right = num1[0];
            sign = 1;
            for (int g = 0; g < n - 1; g++) {
                switch (op[no[g]]) {
                case '+':
                    left = left + sign * right;
                    sign = 1;
                    right = num1[g + 1];
                    break;
                case '-':
                    left = left + sign * right;
                    sign = -1;
                    right = num1[g + 1];
                    break;
                case '*':
                    right = right * num1[g + 1];
                    break;
                case '/':
                    right = right / num1[g + 1];
                    break;
                }
            }
            result = left + sign * right;
            Main.staticanser[i] = String.valueOf(Main.decimal.format(left+ sign * right));
            i++;
    }

    public float getResult() {
        return this.result;
    }
}

测试类：

package h1;

import static org.junit.Assert.*;

import org.junit.Assert;
import org.junit.Test;

import Excep.YichangException;
import h2.Core;

public class CoreTest {
    @Test
    public void testAdd() {// 加法
        int n = 3;// 操作数个数
        int[] num1 = { 1, 2, 3 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 1, 1 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
        float r = c.getResult();
        System.out.println(r);
        assertEquals(6, r, 0.1);
    }

    @Test
    public void testJian() {// 减法
        int n = 3;// 操作数个数
        int[] num1 = { 1, 2, 3 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 2, 2 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
        float r = c.getResult();
        System.out.println(r);
        assertEquals(-4, r, 0.1);
    }

    @Test
    public void testMulti() {// 乘法
        int n = 3;// 操作数个数
        int[] num1 = { 2, 2, 3 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 3, 3 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
        float r = c.getResult();
        System.out.println(r);
        assertEquals(12, r, 0.1);
    }

    @Test
    public void testDiv() {// 除法
        int n = 2;// 操作数个数
        int[] num1 = { 2, 4 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 4 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
        float r = c.getResult();
        System.out.println(r);
        assertEquals(0.5, r, 0.1);
    }

    @Test
    public void testNormal() {// 混合运算
        int n = 4;// 操作数个数
        int[] num1 = { 1, 2, 3, 2 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 1, 3, 4 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
        float r = c.getResult();
        System.out.println(r);
        assertEquals(4, r, 0.1);
    }

    @Test(expected = ArithmeticException.class)
    public void testZero() {// 除以零
        int n = 3;// 操作数个数
        int[] num1 = { 1, 0, 3 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 4, 1 };// 操作符下标
        Core c = new Core();
        c.calcute(num1, op, no, n);
    }

    @Test
    public void dealZero() {// 除以零(处理异常)
        int n = 3;// 操作数个数
        int[] num1 = { 1, 0, 3 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 4, 1 };// 操作符下标
        Core c = new Core();
        try {
            c.calcute(num1, op, no, n);// 运算1/0+3
        } catch (Exception e) {
            System.out.println("除数不能为0");
        }
    }
    
    
    @Test
    public void testUnnormal2() {// 非法输入
        int n = 4;// 操作数个数
        int[] num1 = { 1, 2, 3, 2 };// 操作数
        char[] op = { ' ', '+', '-', '*', '/' };// 操作符
        int[] no = { 1, 3, 5};// 操作符下标--------越界
        Core c = new Core();
        try {
            c.calcute(num1, op, no, n);// 运算1+2*3/2
            float r = c.getResult();
            System.out.println(r);
        } catch (Exception e) {
            System.out.println("下标越界，操作符下标越界");
        }
    }

}

截图：

总结：

更新处理了一些奇怪的异常（操作数下标填了个5）。。以及除数为零异常。

用户输入部分未能封装成一个类，但异常处理都有。尝试过，但是出错很多。还没能彻底实现。在总的程序来看，调用Core类时其实是不会出现除数为零或者其他异常的。