四则运算程序-Java程序设计

合集下载

四则运算计算器程序设计(java-GUI)

四则运算计算器程序设计(java-GUI)
四则运算计算器程序设计(java-GUI)
北京林业大学信息学院 闫煜鸿
一、 实例描述
用户通过按钮输入一个四则混合运算表达式,当按下‘=’时能够计算并显示计算结果, 如果用户输入的表达式有错误则要给出 ERROR 提示。
二、 实例分析
本实例需要用户通过按钮输入四则混合运算表达式,那么程序界面需要提供数字和符号 的按钮,同时还需要能够显示输入和输出结果的控件。为了便于布局和管理,使用三个 JButton 数组存放所有的按钮对象,分别为数字键(0 到 9 以及小数点)、运算符键(加、 减、乘、除、括号、等号等)和功能键(包括重置、后退、说明等)。用于显示信息的控件 使用 JLable 类型的对象 lable。
当事件源为‘=’按钮时,除了在 label 后添加字符‘=’,还要调用自定义的方法 EvaluateExpression()得到表达式的值并将此值添加在 lable 之后,同时将 p 的值设为 false。 此时数字键和运算符按钮以及‘后退’键都不可使用。
当事件源为‘重置’按钮时,将 lable 中的字符清空,同时恢复 p 的值为 true。 当事件源为‘说明’按钮时,在 lable 中显示说明文字,同时设置 p 的值为 false,以防 止用户输入的表达式错误。
五、 数据结构与算法设计
如何根据用户输入的字符串表达式计算表达式的值呢?这里介绍使用堆栈来计算表达 式的值的方法。
首先是关于堆栈的描述。使用 java.util 包中的 Stack<E>泛型类可以创建一个堆栈对象。 堆栈对象可以调用 public E push(E item)方法实现入栈操作,及在栈顶插入元素 item;调用 public E pop()方法实现出栈操作,及删除并返回栈顶元素;调用 public boolean empty()方法 判断堆栈是否为空,如果为空则返回 true;调用 public E peek()方法可以获取栈顶元素,但 不删除该元素。在这个程序中需要有两个堆栈对象,分别是用来存放运算数的 OPND 栈(E 为 Float 类型)和存放运算符的 OPTR 栈(E 为 Character 类型)。

java计算器程序代码及文档(带异常处理,括号等。注释详细易懂)

java计算器程序代码及文档(带异常处理,括号等。注释详细易懂)

四则运算计算器设计说明书一.设计目标本次计算器的程序设计,通过使用JA V A中的AWT包和Swing包的类库设计图形界面的计算器。

此计算器能够完成加减乘除的四则混合运算。

利用面向对象程序设计的思想,将各个组件的事件响应分别用不同的方式表达出来,并且使用了图形界面中的事件委托机制来处理事件响应。

二.设计流程1. 分析该计算器需要完成的功能。

用户能够完成添加括号和负号的四则混合运算,并且计算器能够自动识别运算符的优先级,根据用户输入的运算表达式,自动计算出相应的结果。

同时还完成了计算器中C按钮清屏功能和Backspace退格键。

2. 考虑异常处理。

(1)当输入的表达式中出现除零的操作,显示框将显示“Infinity(无穷大)”。

(2)当输入的表达式错误时,将弹出提示框显示“表达式错误请重新输入”(3)当计算器的显示文本框里为没有输入内容时直接点击等号按钮,将弹出提示框显示“对不起,您没有任何输入,请重新输入:”。

(4)当第一次输入乘号键,除号键,右括号,小数点,求余键,等号键,ce 键,Backspace键时提示错误。

4. 考虑数据的处理目标计算表达式通过点击计算器界面上的按钮进行输入,当按下等号之后,计算器通过调用JA V A中script这个包中的相关类和方法来实现数据的处理。

5. 编码实现计算器的功能。

(1)新建相关的文件。

(2)引入JA V A中相关的包。

(3)新建类Jsq,并继承了类Frame,而且实现了接口ActionListener(4)定义相关的变量,创建相关组件,并对组件的属性进行设置。

(5)对所创建的组件进行布局,完成界面的实现。

(6)为各个组件添加事件监听器。

(7)重写事件接口ActionListener的方法public void actionPerformed(ActionEvent e)。

(8)为各个组件编写事件代码,完成每个按钮的不同功能。

三.测试过程的截图1. 程序初始运行界面2运算测试3.混合运算测试:异常处理测试:1.输入错误的表达式2、除数为0时:四.设计结果此计算器以完成设计,所有功能都以实现,并达到了预想的设计目标。

java实现超大整数加减乘除四则运算

java实现超大整数加减乘除四则运算

java实现超⼤整数加减乘除四则运算原理:⽤数组存储数字,按照计算法则进⾏运算。

代码:package com.hdwang;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** ⼤数四则运算(超出long型的⼤数(64位:18446744073709551615))* Created by hdwang on 2017/10/9.*/public class Calculator {/*** 两数相加* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String add(String numStr1, String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;}int[] resultArray = new int[maxLen+1]; //考虑到可能会进位,多给⼀个元素空间//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<minLen;i++){int t = numArray1[i]+numArray2[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<maxLen;i++){int t = maxArray[i]+added; //多余位数加上进位if(t>9){added = 1; //进1resultArray[i] = t-10; //当前位计算结果}else{added = 0; //不进位resultArray[i] = t; //当前位计算结果}}resultArray[i] = added; //最⾼位//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();for(int n=resultArray.length-1;n>=0;n--){//如果最⾼位为0,移除if(n==resultArray.length-1 && resultArray[resultArray.length-1]==0){continue; //跳过}else{builder.append(resultArray[n]);}}return builder.toString();}/*** 两数相减* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String subtract(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //数值⼤的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;maxArray = numArray1;if(numLen1 == numLen2){ //等于maxArray = getMaxNumber(numArray1,numArray2);}}int[] minArray = maxArray==numArray1?numArray2:numArray1; //数值⼩的数int[] resultArray = new int[maxLen];//⼤数-⼩数,同位相减,⼩于0借位int subtracted = 0;int i=0;for(;i<minLen;i++){int t = maxArray[i] - minArray[i] - subtracted; //两数相减,再减借位if(t<0){subtracted = 1; //向⾼位借1,暂存起来resultArray[i] = t+10; //当前位计算结果(借1相当于借了10)}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//⼤数超出部分减掉借位for(;i<maxLen;i++){int t = maxArray[i]-subtracted; //多余位数减掉借位if(t<0){subtracted = 1; //进1resultArray[i] = t+10; //当前位计算结果}else{subtracted = 0; //不借位resultArray[i] = t; //当前位计算结果}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean highBitNotEqualZero = false; //存在⾼位不为0的情况,低位0保留for(int n=resultArray.length-1;n>=0;n--){//如果⾼位为0,移除if(resultArray[n]==0 && !highBitNotEqualZero && n!=0){ //⾼位⽆⽤的0去除continue; //跳过}else{highBitNotEqualZero = true; //找到不为0的位builder.append(resultArray[n]);}}if(maxArray == numArray1){ //第⼀个数⼤或相等}else{ //第⼀个数⼩于第⼆个数,相减为负数builder.insert(0,"-");}return builder.toString();}/*** 两数相乘* @param numStr1 数1* @param numStr2 数2* @return结果*/public static String multiply(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int minLen = 0; //取长度⼩的数位数int maxLen = 0; //取长度⼤的数位数int[] maxArray = null; //长度⼤的数int[] minArray = null; //长度⼩的数if(numLen1<numLen2){minLen = numLen1;maxLen = numLen2;minArray = numArray1;maxArray = numArray2;}else{minLen = numLen2;maxLen = numLen1;minArray = numArray2;maxArray = numArray1;}//⼆维数组存储结果,例如:23*23 ->[[6,9],[4,6]] ,内部括号(低维)存某位的相乘结果,⾼维低位存个位,⼗位...int[][] resultArray = new int[minLen][maxLen+1];//长度⼤的数*长度⼩的数的每⼀位,分别存到相应数组中,然后累加for(int h=0;h<minLen;h++){ //⾼维int l=0;int added = 0;for(;l<maxLen;l++){ //低维int t = maxArray[l]*minArray[h]+added; //长度⼤的数的每⼀位*长度⼩的数的个位、⼗位...if(t>9){added = t/10; //进位resultArray[h][l] = t%10; //当前位计算结果}else{added = 0; //不进位resultArray[h][l] = t; //当前位计算结果}}resultArray[h][l] = added; //个位、⼗位...的计算结果的最⾼位}//对结果补位(左移),个位不动,⼗位补0,百位补00...,然后累加int[] sum = null; //最终累加结果int[] lowBitResult = null; //低位补0结果(前⼀位)for(int h=0;h<minLen;h++){int[] bitResult = resultArray[h];int[] r; //个位、⼗位...的补0结果if(h==0){ //个位r = bitResult;sum = r;lowBitResult = r; //记录下来,待下次循环累加}else{ //⼗位...的计算结果r = new int[resultArray[h].length+h]; //初始化默认就是0的int rLen = r.length-1;for(int i=bitResult.length-1;i>=0;i--){ //从⾼位开始复制到新数组r[rLen--] = bitResult[i];}//累加之前的数sum = new int[r.length+1]; //取⾼位长度+1,可能进位//================加法核⼼算法====================//两数长度相同的部分,同位相加,超出9进1int added = 0;int i=0;for(;i<lowBitResult.length;i++){int t = lowBitResult[i]+r[i]+added; //两数相加,再加进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}//长度超出部分累加for(;i<r.length;i++){int t = r[i]+added; //多余位数加上进位if(t>9){added = 1; //进1sum[i] = t-10; //当前位计算结果}else{added = 0; //不进位sum[i] = t; //当前位计算结果}}sum[i] = added; //最⾼位//===============================================lowBitResult = sum; //记录下来,待下次循环累加}}//拼接结果 [1,4,8,2,0] -> 2841StringBuilder builder = new StringBuilder();boolean existHighNotZero = false; //⾼位存在不为0的,这个0就不能移除for(int n=sum.length-1;n>=0;n--){//移除⾼位⽆效的0,保留最后⼀个0if(sum[n]==0 && !existHighNotZero && n!=0){continue; //跳过}else{existHighNotZero = true;builder.append(sum[n]);}}return builder.toString();/*** 两数相除* @param numStr1 数1(被除数)* @param numStr2 数2(除数,不能超过long型)* @return结果*/public static String divide(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) long yu = 0;int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){long num = yu * 10 + numArray1[i]; //被除数该位为:余数*10+⾃⼰int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[resultIndex--] = r;}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(yu!=0){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){long num = yu * 10 + 0; //⼩数部分被除数补0int r= (int)(num / Long.parseLong(numStr2)); //取整yu = num % Long.parseLong(numStr2); //取余resultArray[decimal--] = r;if(yu==0){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 两数相除(增强版)* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return结果*/public static String divideEnhanced(String numStr1,String numStr2){int numLen1 = numStr1.length();int numLen2 = numStr2.length();int[] numArray1 = new int[numLen1]; //数字数组int[] numArray2 = new int[numLen2];// "12345"-> [5,4,3,2,1]for(int i=0;i<numLen1;i++){String c = numStr1.substring(i,i+1);numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}for(int i=0;i<numLen2;i++){String c = numStr2.substring(i,i+1);numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字}int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认⼤数长度+16int[] resultArray = new int[effectiveNum]; //⾼位存⾼位//将被除数的每⼀位除以除数,取整为该位结果,取余暂存借给低位(除数不能⼤过long型,除⾮除法转换为减法) String yu = "0";int resultIndex = effectiveNum-1;for(int i=numArray1.length-1;i>=0;i--){String num = "0".equals(yu)?numArray1[i]+"":add(yu+"0",numArray1[i]+""); //被除数该位为:余数*10+⾃⼰ DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[resultIndex--] = Integer.parseInt(r); //某位上的结果肯定⼩于10}int decimalPoint = effectiveNum-numArray1.length-1; //⼩数点位置if(!"0".equals(yu)){int decimal = decimalPoint; //⼩数for(int i=0;i<effectiveNum-numArray1.length;i++){String num = yu+"0"; //⼩数部分被除数补0DivideResult result = getDivideResult(num,numStr2);String r= result.getR() ; //取整yu = result.getYu(); //取余resultArray[decimal--] = Integer.parseInt(r);if("0".equals(yu)){break; //余数为0,提前退出}}}//拼接结果StringBuilder builder = new StringBuilder();boolean existHighNotZero = false;for(int i=effectiveNum-1;i>=0;i--){if(i==decimalPoint){builder.append(".");}if(resultArray[i]==0){if(!existHighNotZero && i>decimalPoint+1){ //跳过⾼位⽆⽤的0continue;}}else{existHighNotZero = true;}builder.append(resultArray[i]);}String result = builder.toString();//去除尾部⽆⽤的0int endIndex = result.length();for(int i=result.length()-1;i>=0;i--){char c = result.charAt(i);if(c!='0'){endIndex = i+1;break;}}//去除多余的⼩数点if(result.charAt(endIndex-1)=='.'){endIndex = endIndex-1;}result = result.substring(0,endIndex);return result;}/*** 校验数字是否合法* @param numStr 数字字符串* @return是否合法*/public static boolean numberValid(String numStr){Pattern pattern = pile("^[1-9]\\d*$|0");Matcher matcher = pattern.matcher(numStr);return matcher.matches();}/*** 计算⼤数* @param numArray1 数1* @param numArray2 数2* @return⼤数*/public static int[] getMaxNumber(int[] numArray1, int[] numArray2) {for(int i=numArray1.length-1;i>=0;i--){if(numArray1[i]>numArray2[i]){return numArray1;}else{if(numArray1[i]==numArray2[i]){continue; //待继续⽐较}else{return numArray2;}}}return numArray1; //全部相等,返回第⼀个}/*** 除法转换为减法* @param numStr1 数1(被除数)* @param numStr2 数2(除数)* @return除的结果*/public static DivideResult getDivideResult(String numStr1,String numStr2){DivideResult result = new DivideResult();String r = "";// String times = "0";int times = 0; //取整不会⼤于9的(被除数(余数+某位)/除数(肯定⼤于余数)这个过程是,被除数逐渐增⼤到可以除以除数为⽌,此时被除数>=除数,刚刚好,所以被除数最多⽐除数多1位,两数相差肯定⼩于10倍)while (true){r=subtract(numStr1,numStr2);// times = add(times,"1"); //次数递增times++;if("0".equals(r)){ //除尽了result.setYu("0");result.setR(times+"");break;}else if(r.startsWith("-")){ //负数,多减了⼀次result.setYu(numStr1); //上次减下来多余的数值,就是余数// result.setR(subtract(times,"1"));result.setR((times-1)+"");break;}numStr1 = r; //被减数重置为剩余的数值}return result;}}package com.hdwang;/*** Created by hdwang on 2017/10/10.* 相除结果*/public class DivideResult {/*** 取整结果*/private String r;/*** 取余结果*/private String yu;public String getR() {return r;}public void setR(String r) {this.r = r;}public String getYu() {return yu;}public void setYu(String yu) {this.yu = yu;}}package com.hdwang;import java.util.Scanner;import static com.hdwang.Calculator.*;public class Main {public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);boolean loop = true;while (loop) {System.out.println("请输⼊第⼀个⾮负整数:");String numStr1 = scanner.nextLine();if (!numberValid(numStr1)) {System.out.println(String.format("%s不合法", numStr1));continue;}System.out.println("请输⼊第⼆个⾮负整数:");String numStr2 = scanner.nextLine();if (!numberValid(numStr2)) {System.out.println(String.format("%s不合法", numStr2));continue;}String r1 = add(numStr1, numStr2);System.out.println(String.format("⼤数加法计算:%s+%s%s=%s", numStr1, numStr2,r1.length()>50?"\n":"", r1));try {System.out.println("加法直接计算:" + (Long.parseLong(numStr1) + Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("加法直接计算:"+ex.getClass().getName());}String r2 = subtract(numStr1, numStr2);System.out.println(String.format("⼤数减法计算:%s-%s%s=%s", numStr1, numStr2,r2.length()>50?"\n":"", r2));try {System.out.println("减法直接计算:" + (Long.parseLong(numStr1) - Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("减法直接计算:"+ex.getClass().getName());}String r3 = multiply(numStr1, numStr2);System.out.println(String.format("⼤数乘法计算:%s*%s%s=%s", numStr1, numStr2,r3.length()>50?"\n":"", r3));try {System.out.println("乘法直接计算:" + (Long.parseLong(numStr1) * Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("乘法直接计算:"+ex.getClass().getName());}try {String r4 = divide(numStr1, numStr2);System.out.println(String.format("⼤数除法计算:%s/%s%s=%s", numStr1, numStr2, r4.length() > 50 ? "\n" : "", r4)); }catch (Exception ex){System.out.println("⼤数除法计算:"+ex.getClass().getName());}try {System.out.println("除法直接计算:" + ((double)Long.parseLong(numStr1) / (double) Long.parseLong(numStr2)));}catch (Exception ex){System.out.println("除法直接计算:"+ex.getClass().getName());}String r5 = divideEnhanced(numStr1, numStr2);System.out.println(String.format("增强版⼤数除法计算:%s/%s%s=%s", numStr1, numStr2,r5.length()>50?"\n":"", r5)); System.out.println("退出输⼊q,否则继续");String line = scanner.nextLine();if(line.equalsIgnoreCase("Q")){loop = false;}else{loop = true;}}}}运⾏结果:请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:1⼤数加法计算:1+1=2加法直接计算:2⼤数减法计算:1-1=0减法直接计算:0⼤数乘法计算:1*1=1乘法直接计算:1⼤数除法计算:1/1=1除法直接计算:1.0增强版⼤数除法计算:1/1=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:2请输⼊第⼆个⾮负整数:3⼤数加法计算:2+3=5加法直接计算:5⼤数减法计算:2-3=-1减法直接计算:-1⼤数乘法计算:2*3=6乘法直接计算:6⼤数除法计算:2/3=0.6666666666666666除法直接计算:0.6666666666666666增强版⼤数除法计算:2/3=0.6666666666666666退出输⼊q,否则继续请输⼊第⼀个⾮负整数:25请输⼊第⼆个⾮负整数:25⼤数加法计算:25+25=50加法直接计算:50⼤数减法计算:25-25=0减法直接计算:0⼤数乘法计算:25*25=625乘法直接计算:625⼤数除法计算:25/25=1除法直接计算:1.0增强版⼤数除法计算:25/25=1退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:50⼤数加法计算:100+50=150加法直接计算:150⼤数减法计算:100-50=50减法直接计算:50⼤数乘法计算:100*50=5000乘法直接计算:5000⼤数除法计算:100/50=2除法直接计算:2.0增强版⼤数除法计算:100/50=2退出输⼊q,否则继续请输⼊第⼀个⾮负整数:3请输⼊第⼆个⾮负整数:4⼤数加法计算:3+4=7加法直接计算:7⼤数减法计算:3-4=-1减法直接计算:-1⼤数乘法计算:3*4=12乘法直接计算:12⼤数除法计算:3/4=0.75除法直接计算:0.75增强版⼤数除法计算:3/4=0.75退出输⼊q,否则继续请输⼊第⼀个⾮负整数:4请输⼊第⼆个⾮负整数:3⼤数加法计算:4+3=7加法直接计算:7⼤数减法计算:4-3=1减法直接计算:1⼤数乘法计算:4*3=12乘法直接计算:12⼤数除法计算:4/3=1.3333333333333333除法直接计算:1.3333333333333333增强版⼤数除法计算:4/3=1.3333333333333333退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100⼤数加法计算:1+100=101加法直接计算:101⼤数减法计算:1-100=-99减法直接计算:-99⼤数乘法计算:1*100=100乘法直接计算:100⼤数除法计算:1/100=0.01除法直接计算:0.01增强版⼤数除法计算:1/100=0.01退出输⼊q,否则继续请输⼊第⼀个⾮负整数:100请输⼊第⼆个⾮负整数:1⼤数加法计算:100+1=101加法直接计算:101⼤数减法计算:100-1=99减法直接计算:99⼤数乘法计算:100*1=100乘法直接计算:100⼤数除法计算:100/1=100除法直接计算:100.0增强版⼤数除法计算:100/1=100退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:10000000000⼤数加法计算:1+10000000000=10000000001加法直接计算:10000000001⼤数减法计算:1-10000000000=-9999999999减法直接计算:-9999999999⼤数乘法计算:1*10000000000=10000000000乘法直接计算:10000000000⼤数除法计算:1/10000000000=0.0000000001除法直接计算:1.0E-10增强版⼤数除法计算:1/10000000000=0.0000000001退出输⼊q,否则继续请输⼊第⼀个⾮负整数:1请输⼊第⼆个⾮负整数:100000000000000000000000000000000000000000000000000⼤数加法计算:1+100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000001加法直接计算:ng.NumberFormatException⼤数减法计算:1-100000000000000000000000000000000000000000000000000=-99999999999999999999999999999999999999999999999999减法直接计算:ng.NumberFormatException⼤数乘法计算:1*100000000000000000000000000000000000000000000000000=100000000000000000000000000000000000000000000000000乘法直接计算:ng.NumberFormatException⼤数除法计算:ng.NumberFormatException除法直接计算:ng.NumberFormatException增强版⼤数除法计算:1/100000000000000000000000000000000000000000000000000=0.00000000000000000000000000000000000000000000000001退出输⼊q,否则继续说明:当数字的⼤⼩超过long类型的数值范围时,将⽆法对数值进⾏计算,所以必须实现⼀套算法。

四则运算实现2(JAVA)

四则运算实现2(JAVA)

四则运算实现2(JAVA)之前做了个流程版的,这⾥放最后的总结版先讲功能实现:1.整体程序是个100以内的四则运算出题器;2.做了个选择菜单,你可以⾃由选择需要做加减乘除任意⼀项的四则运算练习;3.增加了内层中的返回功能,使得运⾏过程中不必退出;4.出题器中提供出题,检验答案和揭⽰答案功能。

下⾯是程序实现截图以及代码实现:菜单⾯板:package Live;import java.awt.*;import javax.swing.*;import java.awt.event.*;public class SizeCaidan extends JFrame{JFrame f = new JFrame("运算选择");JPanel p = new JPanel();public SizeCaidan() {JButton b1 = new JButton("加法练习");JButton b2 = new JButton("减法练习");JButton b3 = new JButton("乘法练习");JButton b4 = new JButton("除法练习");JButton ex = new JButton("退出");b1.addActionListener(new Monitor2());b2.addActionListener(new Monitor2());b3.addActionListener(new Monitor2());b4.addActionListener(new Monitor2());ex.addActionListener(new Monitor2());f.addWindowListener(new Wind());f.add(p);p.setLayout(new GridLayout(1, 2));Icon icon=new ImageIcon("src/Live/gdjssfdx.jpg");//JLabel label=new JLabel(icon);label.setBounds(0,0,400,350);f.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));JPanel jp = (JPanel)f.getContentPane();jp.setOpaque(false);//JLabel l = new JLabel();JPanel p2 = new JPanel();p.add(l);p.add(p2);p2.setLayout(new GridLayout(5, 1));p2.add(b1);p2.add(b2);p2.add(b3);p2.add(b4);p2.add(ex);p.setOpaque(false);f.setBounds(200, 200, 400, 400);f.setVisible(true);}public static void main(String[] args) {new SizeCaidan();}private class Wind extends WindowAdapter {public void windowClosing(WindowEvent e) {f.setVisible(false);System.exit(0);}}private class Monitor2 implements ActionListener { @Overridepublic void actionPerformed(ActionEvent e) {if (e.getActionCommand().equals("退出")) {//new SizeCaidan();System.exit(0);}if (e.getActionCommand().equals("加法练习")) {new NumJframe();f.setVisible(false);}if (e.getActionCommand().equals("减法练习")) {new NumJframe2();f.setVisible(false);}if (e.getActionCommand().equals("乘法练习")) {new NumJframe3();f.setVisible(false);}if (e.getActionCommand().equals("除法练习")) {new NumJframe4();f.setVisible(false);}}}}菜单⾯板加法练习⾯板:package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;import Live.JiafaSum;public class Jia_1 {public static void main(String[] args) {new NumJframe();}}class JiafaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的,// 所以采⽤定义类变量的⽅法)public static int sum = 0;}class NumJframe extends JFrame {public NumJframe() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();//返回bank4();//揭⽰答案setTitle("100以內的加法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.yellow);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;JiafaSum.sum = jiashu1 + jiashu2;jt.setText(js1 + "+" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮2jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = JiafaSum.sum;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(JiafaSum.sum+"");}});add(jt4);add(jb4);}}加法以加法为例,其他三则运算也类似,以下直接贴出代码(PS:除法中因为变量提取为int型,所以除法结果也只保留整数部分)package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Jian_1 {public static void main(String[] args) {new NumJframe2();}}class JianfaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum2 = 0;}class NumJframe2 extends JFrame {public NumJframe2() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的减法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.cyan);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jianshu1 = (int) (Math.random() * 100 + 1);int jianshu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jianshu1;String js2 = "" + jianshu2;JianfaSum.sum2 = jianshu1 - jianshu2;jt.setText(js1 + "-" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = JianfaSum.sum2;String inputSum = jt2.getText();// System.out.println("sum="+sum);// System.out.println("inputSum="+inputSum);if (inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null, "答案正确", "消息对话框", RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null, "答案错误", "消息对话框", JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(JianfaSum.sum2+"");}});add(jt4);add(jb4);}}减法package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Cheng {public static void main(String[] args) {new NumJframe3();}}class ChengfaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum3 = 0;}class NumJframe3 extends JFrame {public NumJframe3() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的乘法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.darkGray);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;ChengfaSum.sum3 = jiashu1 * jiashu2;jt.setText(js1 + "X" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = ChengfaSum.sum3;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE); }else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(ChengfaSum.sum3+"");}});add(jt4);add(jb4);}}乘法package Live;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JTextField;public class Chu_1 {public static void main(String[] args) {new NumJframe4();}}class ChufaSum {// 定义全局变量(其实就是类变量,因为在JAVA中不存在全局变量的声明,但是类默认是static的, // 所以采⽤定义类变量的⽅法)public static int sum4 = 0;}class NumJframe4 extends JFrame {public NumJframe4() {setLayout(null);Container con = getContentPane();// 创建⼀个内容⾯板容器bank1();// 获得题⽬bank2();// 确认答案bank3();bank4();setTitle("100以內的除法测试");setBounds(200, 200, 600, 300);// 设置出现位置和窗⼝⼤⼩setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置关闭⽅式setVisible(true);// 设置是否展⽰窗⼝con.setBackground(Color.orange);}void bank1() {// 获得题⽬按钮区JTextField jt = new JTextField();// ⽂本框1jt.setBounds(120, 40, 200, 30);JButton jb1 = new JButton();// 按钮1jb1.setBounds(20, 40, 100, 30);jb1.setText("获得题⽬");jb1.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int jiashu1 = (int) (Math.random() * 100 + 1);int jiashu2 = (int) (Math.random() * 100 + 1);String js1 = "" + jiashu1;String js2 = "" + jiashu2;ChufaSum.sum4 = jiashu1 / jiashu2;jt.setText(js1 + "÷" + js2 + "=" + "");}});add(jt);add(jb1);}void bank2() {// 确认答案按钮区JTextField jt2 = new JTextField();// ⽂本框2jt2.setBounds(120, 75, 200, 30);JButton jb2 = new JButton();// 按钮1jb2.setBounds(20, 75, 100, 30);jb2.setText("确认答案");jb2.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {int sum = ChufaSum.sum4;String inputSum = jt2.getText();//System.out.println("sum="+sum);//System.out.println("inputSum="+inputSum);if(inputSum == null) {System.out.println("你的输⼊有误,请重新输⼊⼀个整数:");}int inputsum = Integer.parseInt(inputSum);if (inputsum == sum) {JOptionPane.showMessageDialog(null,"答案正确","消息对话框",RMATION_MESSAGE);}else {JOptionPane.showMessageDialog(null,"答案错误","消息对话框",JOptionPane.WARNING_MESSAGE);}}});add(jt2);add(jb2);}void bank3() {//返回区JButton jb3 = new JButton();//jb3.setBounds(0, 0, 100, 25);jb3.setText("返回");jb3.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {setVisible(false);new SizeCaidan();}});add(jb3);}void bank4() {//输出答案区JTextField jt4 = new JTextField();// ⽂本框1jt4.setBounds(120, 110, 200, 30);JButton jb4 = new JButton();// 按钮1jb4.setBounds(20, 110, 100, 30);jb4.setText("揭⽰答案");jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {jt4.setText(ChufaSum.sum4+"");}});add(jt4);add(jb4);}}除法以上即为该四则运算的最终代码版。

Java实现四则混合运算代码示例

Java实现四则混合运算代码示例

Java实现四则混合运算代码⽰例使⽤栈来实现,可以处理运算优先级。

使⽤⾃然四则运算表达式即可,如:4+(3*(3-1)+2)/2。

⽆需把表达式先转换为逆波兰等形式。

package com.joshua.cal;import java.util.Collections;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.Set;import java.util.Stack;public class Calculator {private final Stack<Double> numStack = new Stack<Double>();private final Stack<Character> opStack = new Stack<Character>();private char currentOperator;private char opStackTop;private int i;private String expression;@SuppressWarnings("rawtypes")public void exec(String expression) {try {clean();if (expression == null || expression.isEmpty()) {throw new IllegalArgumentException("Blank Expression!");}this.expression = expression;opStack.push(TERMINATE_TOKENS.START_END_MARK);List tokens = TOKENIZER.exec(expression+ TERMINATE_TOKENS.START_END_MARK);for (; i < tokens.size(); i++) {final Object token = tokens.get(i);if (token instanceof Double) {processOperand((double) token);} else {processOperator((char) token);}}} catch (Throwable e) {System.err.println(String.format("Incorret Expression: %s\nError: %s", expression,e.getMessage()));}}private void processOperand(final double operand) {numStack.push(operand);}private void processOperator(final char currentOperator) {this.currentOperator = currentOperator;this.opStackTop = opStack.peek();char calMode = CALCULATE_MODE.getRule(currentOperator, opStackTop);switch (calMode) {case '>':processStackHigerPriorityOperator();break;case '<':processStackLowerPriorityOperator();break;case '=':processStackEqualPriorityOperator();break;default:break;}}private void processStackLowerPriorityOperator() {opStack.push(currentOperator);}private void processStackHigerPriorityOperator() {numStack.push(CALCULATE.exec(opStack.pop(), numStack.pop(),numStack.pop()));--i; // pointer back to the previous operator.}private void processStackEqualPriorityOperator() {if (TERMINATE_TOKENS.START_END_MARK == currentOperator) {System.out.println(expression + " = " + numStack.peek());} else if (')' == currentOperator) {opStack.pop();}}public void clean() {numStack.clear();opStack.clear();i = 0;}public static void main(String[] args) {Calculator cal = new Calculator();cal.exec("4+(3*(3-1)+2)/2"); // = 8cal.exec("4 + (-3 * ( 3 - 1 ) + 2)"); // = 0cal.exec("4 +-/ (-3 * ( 3 - 1 ) + 2)"); // incorrect expression!cal.exec("4.5+(3.2+3)/2"); // = 7.6cal.exec("4.5+(3.2:3)/2"); // incorrect expression!cal.exec("-4.5+(3.2-3)/2"); // = -4.4}}enum CALCULATE {INSTANCE;public static double exec(final char operator, final double right,final double left) {switch (operator) {case '+':return left + right;case '-':return left - right;case '*':return left * right;case '/':return left / right;default:throw new IllegalArgumentException("Unsupported operator: "+ operator);}}}enum TERMINATE_TOKENS {INSTANCE;public static final char START_END_MARK = '#';private static final Map<Character, Integer> TOKENs = new HashMap<Character, Integer>(); static {// token, token idTOKENs.put('+', 0);TOKENs.put('-', 1);TOKENs.put('*', 2);TOKENs.put('/', 3);TOKENs.put('(', 4);TOKENs.put(')', 5);TOKENs.put(START_END_MARK, 6);}private static Set<Character> NEGATIVE_NUM_SENSITIVE = new HashSet<Character>(); public static synchronized Set<Character> getNegativeNumSensitiveToken() {if (NEGATIVE_NUM_SENSITIVE.size() == 0) {NEGATIVE_NUM_SENSITIVE.addAll(TOKENs.keySet());NEGATIVE_NUM_SENSITIVE.remove(')');}return NEGATIVE_NUM_SENSITIVE;}public static boolean isTerminateToken(final char token) {Set<Character> keys = TOKENs.keySet();return keys.contains(token);}public static int getTokenId(final char token) {return TOKENs.get(token) == null ? -1 : TOKENs.get(token);}public static int getTokenSize() {return TOKENs.size();}}enum CALCULATE_MODE {INSTANCE;private static char[][] RULES = {// + - * / ( ) #{ '>', '>', '<', '<', '<', '>', '>' }, // +{ '>', '>', '<', '<', '<', '>', '>' }, // -{ '>', '>', '>', '>', '<', '>', '>' }, // *{ '>', '>', '>', '>', '<', '>', '>' }, // /{ '<', '<', '<', '<', '<', '=', 'o' }, // ({ '>', '>', '>', '>', 'o', '>', '>' }, // ){ '<', '<', '<', '<', '<', 'o', '=' }, // #};static {if (RULES.length != TERMINATE_TOKENS.getTokenSize() || RULES.length < 1|| RULES[0].length != TERMINATE_TOKENS.getTokenSize()) {throw new IllegalArgumentException("Rules matrix is incorrect!");}}public static char getRule(final char currentOperator, final char opStackTop) {try {return RULES[TERMINATE_TOKENS.getTokenId(opStackTop)][TERMINATE_TOKENS .getTokenId(currentOperator)];} catch (Throwable e) {throw new RuntimeException("No rules were defined for some token!");}}}enum TOKENIZER {INSTANCE;private static final StringBuilder BUFFER = new StringBuilder();private static String clearExpression(String expression) {return expression.replaceAll(" ", "");}private static Character PREVIOUS_CHAR;private static void clean() {BUFFER.delete(0, BUFFER.length());PREVIOUS_CHAR = null;}private static boolean processNegativeNumbers(final String exp,final int index) {char c = exp.charAt(index);if (('+' == c || '-' == c)&& (PREVIOUS_CHAR == null || TERMINATE_TOKENS.getNegativeNumSensitiveToken().contains(PREVIOUS_CHAR))&& !TERMINATE_TOKENS.isTerminateToken(exp.charAt(index + 1))) {BUFFER.append(c);return true;}return false;}@SuppressWarnings({ "unchecked", "rawtypes" })public static List<?> exec(final String expression) {clean();String exp = clearExpression(expression);List result = new LinkedList();for (int i = 0; i < exp.length(); i++) {char c = exp.charAt(i);if (TERMINATE_TOKENS.isTerminateToken(c)) {if (processNegativeNumbers(exp, i))continue;if (BUFFER.length() > 0) {result.add(Double.valueOf(BUFFER.toString()));BUFFER.delete(0, BUFFER.length());}result.add(c);} else {BUFFER.append(c);}PREVIOUS_CHAR = c;}return Collections.unmodifiableList(result);}}输出4+(3*(3-1)+2)/2 = 8.04 + (-3 * ( 3 - 1 ) + 2) = 0.04.5+(3.2+3)/2 = 7.6-4.5+(3.2-3)/2 = -4.4Incorret Expression: 4 +-/ (-3 * ( 3 - 1 ) + 2)Error: nullIncorret Expression: 4.5+(3.2:3)/2Error: For input string: "3.2:3"总结以上就是本⽂关于实现四则混合运算代码⽰例的全部内容,希望对⼤家有所帮助。

四则运算代码(java版本)采用正则表达式

四则运算代码(java版本)采用正则表达式

四则运算代码(java版本)采⽤正则表达式//加减乘除负数、括号这⼏种//具体看代码以及注释 (测试没发现bug,如发现有bug 请指正)package com.test;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/*** 四则运算,可能不是最优的写法,⾃⼰测试没发现bug<br>* 前提:正确的算式,因为没做算式的验证<br>* 思路:<br>* 1、⽤正则拆分所有的元素例⼦:2-5+4*5/(2+2)-4<br>* 拆分为【2,-5,4,*,5,/,(,2,2,),-4】<br>* 2、先计算括号⾥,乘除,最后加减** 总结:总体花了17、8个⼩时,主要原因还是没有仔细总体分析流程导致。

<br>* 以⾄于想到点写点代码、修修改改,没有⼀个完整的把握的思路。

所以⼀个问题⼀定<br>* 先⾛通整个思路、流程其实编码是最容易的,重点是处理的过程思路** @author wangshiyan* @time 2014-12-4 下午12:50:01**/public class SizheTool {public static void main(String[] args) {try {System.out.println(jisuanStr("11.2+3.1*(423-(2+5.7*3.4)+5.6)-6.4/(15.5+24)"));} catch (Exception e) {System.out.println("请检查你的算式格式");e.printStackTrace();}}/*** 拆分算式⾥的各个元素并处理对应所在位置<br>** @param str* @return*/public static List<String> splitStr(String string) throws Exception {List<String> listSplit = new ArrayList<String>();Matcher matcher = pile("\\-?\\d+(\\.\\d+)?|[*/()]|\\-").matcher(string);// ⽤正则拆分成每个元素while (matcher.find()) {// System.out.println(matcher.group(0));listSplit.add(matcher.group(0));}return listSplit;}/*** 计算<br>* 步骤:1、如果有括号<br>* 然后取上⼀个最近的(坐标计算当前括号组合⾥的算式),在继续往下查找括号以此类推,直⾄循环使⽤到所有坐标元素* 计算完毕(运算顺序括号、乘除、加减)** @param str* @return*/public static double jisuanStr(String str) throws Exception {double returnDouble = 0;List<String> listSplit = splitStr(str); // 拆分好的元素List<Integer> zKuohaoIdxList = new ArrayList<Integer>();// 左括号,<所在坐标,>if (pile(".*\\(|\\).*").matcher(str).find()) {// 如果包含括号运算String value = "";// 单个字符值int zIdx = 0;// 上⼀个左括号在zKuoHaoIdxList的下标// 此层循环计算完所有括号⾥的算式List<String> tempList = new ArrayList<String>();// 前⾯没有计算的元素int removeL = 0;int tempListSize = 0;for (int i = 0; i < listSplit.size(); i++) {value = listSplit.get(i);tempList.add(value);tempListSize = tempList.size();if ("(".equals(value)) {// 左括号zKuohaoIdxList.add(tempListSize-1);} else if (")".equals(value)) {// 遇到右括号就计算与上⼀左括号间的算式zIdx = zKuohaoIdxList.size() - 1;// 离当前右括号最近的左括号配对int start = zKuohaoIdxList.get(zIdx);returnDouble = jisuan(tempList, start + 1, tempListSize-1); // 开始位置,就是上⼀个左括号 removeL = tempListSize - start;tempList = removeUseList(tempList, removeL);// 移除已使⽤的元素tempList.add(returnDouble + "");// 刚刚计算的值添加进来zKuohaoIdxList.remove(zIdx);// 计算完毕清除括号}}// 把所有计算完returnDouble = jisuan(tempList, 0, tempList.size());} else {// 没有括号运算returnDouble = jisuan(listSplit, 0, listSplit.size());}return returnDouble;}/*** 倒序删除已⽤过的元素** @param list* @param removeLength* 数量* @return*/public static List<String> removeUseList(List<String> list, int removeLength) {int le = list.size() - removeLength;for (int i = list.size() - 1; i >= le; i--) {list.remove(i);}return list;}/*** 计算算式** @param listSplit* @param start* 括号算式开始符位置* @param end* 括号结束符位置* @return*/public static double jisuan(List<String> listSplit, int start, int end)throws Exception {double returnValue = 0;String strValue = null;// 临时变量List<String> jjValueList = new ArrayList<String>();// 剩下的加减元素// 遍历计算乘除法for (int i = start; i < end; i++) {strValue = listSplit.get(i);if ("*".equals(strValue) || "/".equals(strValue)) {// 乘除strValue = jisuanValue("*".equals(strValue) ? "*" : "/", Double.parseDouble(jjValueList.get(jjValueList.size() - 1)),Double.parseDouble(listSplit.get(i + 1)))+ "";jjValueList.remove(jjValueList.size() - 1);i++;}jjValueList.add(strValue);}// 遍历计算加减for (int j = 0; j < jjValueList.size(); j++) {strValue = jjValueList.get(j);if ("-".equals(strValue) || "+".equals(strValue)) {returnValue = jisuanValue("-".equals(strValue) ? "-" : "+",returnValue, Double.parseDouble(jjValueList.get(j + 1)));j++;} else {returnValue += Double.parseDouble(jjValueList.get(j));}}return returnValue;}/*** 计算2个数间的加减乘除操作如:2*5 ,2/5** @param type* 运算符* @param start* 数相当于上⾯2* @param end* 被数相当于上⾯5* @return*/public static double jisuanValue(String type, double start, double end) throws Exception {double d = 0;if ("-".equals(type)) {d = start - end;} else if ("+".equals(type)) {d = start + end;} else if ("*".equals(type)) {d = start * end;} else if ("/".equals(type)) {if (0 == start || 0 == end)d = 0;elsed = start / end;}return d;}}。

Java实现四则运算

Java实现四则运算

Java实现四则运算本次使⽤java语⾔,实现了四则运算习题的⽣成。

⼀、主要功能:(1)算式个数(2)是否有乘除法(3)结果集数值范围(4)加减法有⽆负数(5)除法有⽆余数(6)除法出现⼩数是否⽀持分数显⽰(7)选择⽣成算式导⼊的⽂件(8)输出打印每⾏个数⼆、代码实现:(1)IFormulaGenerationpackage cn.zhl.software;import java.util.Map;public interface IFormulaGeneration {//加法⽣成接⼝,结果范围,加法有⽆负数,⽣成个数public Map<String,Integer> Add(int resultRange,boolean is,int num);//减法⽣成接⼝,结果范围,减法有⽆负数,⽣成个数public Map<String,Integer> Sub(int resultRange,boolean is,int num);//乘法⽣成接⼝,⽣成个数public Map<String,Integer> Mul(int resultRange,int num);//除法⽣成接⼝,结果范围,除法有⽆余数,是否⽀持分数,⽣成个数public Map<String,String> Div(int resultRange,boolean is,boolean is2,int num);//检测算式是否存在重复,如果存在返回truepublic boolean Repeat(Map<?,?> map,String formula);//⽣成特定范围的数值public int nextInt(int min, int max);//算法⽣成器:算式个数,是否有乘除法,数值范围,加减法有⽆负数,除法⼜⽆余数,是否⽀持分数,打印每⾏个数 public Map<String,?> FormulaCustom(int formulaNum,boolean if_MulDiv,int range,boolean ifNeg_AddSub,boolean ifRem_Div,boolean ifRed_Div,int lineNum);}(2)FormulaRealizationpackage cn.zhl.software;import java.util.HashMap;import java.util.Map;import java.util.Random;import java.util.Set;public class FormulaRealization implements IFormulaGeneration {Random random = new Random();@Overridepublic Map<String, Integer> Add(int resultRange, boolean is, int num) {if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> addMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange - r1, resultRange - r1);} else {r2 = nextInt(-r1, resultRange - r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "+" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(addMap, formula)) {}return addMap;}@Overridepublic Map<String, Integer> Sub(int resultRange, boolean is, int num) { if (resultRange < 0) {resultRange = -resultRange;}Map<String, Integer> subMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {r1 = nextInt(-resultRange, resultRange);if (is) {//加法允许出现负数r2 = nextInt(-resultRange + r1, resultRange + r1);} else {r2 = nextInt(r1, resultRange + r1);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "-" + (r2 < 0 ? "(" + r2 + ")" : r2); if (Repeat(subMap, formula)) {subMap.put(formula, r1 - r2);n++;}}return subMap;}@Overridepublic Map<String, Integer> Mul(int resultRange, int num) {if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;String formula = "";for (; n < num; ) {while (r1 == 0) {r1 = nextInt(-resultRange, resultRange);}r2 = nextInt(-(int) (resultRange / Math.abs(r1)), (int) (resultRange / Math.abs(r1))); formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "*" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(mulMap, formula)) {mulMap.put(formula, r1 * r2);n++;r1 = nextInt(-resultRange, resultRange);}}return mulMap;}@Overridepublic Map<String, String> Div(int resultRange, boolean is, boolean is2, int num) { if (resultRange == 0) {resultRange = 1;}if (resultRange < 0) {resultRange = -resultRange;}Map<String, String> divMap = new HashMap<>();int r1 = 0, r2 = 0, n = 0;String formula = "";for (; n < num; ) {//r1 = nextInt(-resultRange, resultRange);while (r2 == 0) {r2 = nextInt(-resultRange, resultRange);}if (!is) {//除法没有余数r1 = r2 * nextInt(-(resultRange), resultRange);} else {//有余数r1 = nextInt(-resultRange, resultRange);}formula = (r1 < 0 ? "(" + r1 + ")" : r1) + "/" + (r2 < 0 ? "(" + r2 + ")" : r2);if (Repeat(divMap, formula)) {String result = "";if (is && is2) {//有余数且化为分数if(r1*r2<0){result = "-"+fracReduction(Math.abs(r1), Math.abs(r2));}else {result = fracReduction(Math.abs(r1), Math.abs(r2));}if(r1%r2==0){result = ((double) r1 / r2) + "";}if (is) {result = ((double) r1 / r2) + "";}}if(r1==0){result=0.0+"";}if (r1==-r2){result="-1.0";}divMap.put(formula, result);n++;}}return divMap;}@Overridepublic boolean Repeat(Map<?, ?> map, String formula) { if (map.isEmpty()) {return true;} else {Set<String> strings = (Set<String>) map.keySet(); for (String string : strings) {//如果当前算式与前⾯算式重复返回falseif (string.equals(formula)) {return false;}}//如果当前算式与前⾯算式不存在重复返回truereturn true;}}@Overridepublic int nextInt(int min, int max) {if (min == max) {return max;}return random.nextInt(max - min + 1) + min;public String fracReduction(int numerator, int denominator) {//找到最⼤公约数,然后分别处以最⼤公约数int m = numerator;int n = denominator;int r;while (numerator > 0) {r = denominator % numerator;denominator = numerator;numerator = r;}// if ((m / denominator)==-(n / denominator)){// return "-1.0";// }return m / denominator + "/" + n / denominator;}@Override//算法⽣成器:算式个数,是否有乘除法,数值范围,加减法有⽆负数,除法⼜⽆余数,是否⽀持分数,打印每⾏个数public Map<String, ?> FormulaCustom(int formulaNum, boolean if_MulDiv, int range, boolean ifNeg_AddSub, boolean ifRem_Div, boolean ifRed_Div, int lineNum) {int add = 0, sub = 0, mul = 0, div = 0;add = nextInt(formulaNum/5,formulaNum/3);sub = nextInt((formulaNum - add)/4,(formulaNum - add)/2);mul = nextInt((formulaNum - add - sub)/3,(formulaNum - add - sub)/1);div = formulaNum - add - sub - mul;Map map = new HashMap();if (if_MulDiv) {//如果存在乘除法将算式总数分为四份Map<String, Integer> addMap = Add(range, ifNeg_AddSub, add);Map<String, Integer> subMap = Sub(range, ifNeg_AddSub, sub);Map<String, Integer> mulMap = Mul(range, mul);Map<String, String> divMap = Div(range, ifRem_Div, ifRed_Div, div);map.putAll(addMap);map.putAll(subMap);map.putAll(mulMap);map.putAll(divMap);} else {//不存在则分为两份map.putAll(addMap);map.putAll(subMap);}return map;}}(3)FormulaRealizationTestpackage cn.zhl.test;import cn.zhl.software.FormulaRealization;import org.junit.Test;import java.util.Map;import java.util.Set;public class FormulaRealizationTest {FormulaRealization formulaRealization = new FormulaRealization();@Testpublic void testAdd() {Map<String, Integer> add = formulaRealization.Add(100, false, 5); for (String s : add.keySet()) {System.out.print(s+"="+add.get(s)+" ");}}@Testpublic void testSub() {Map<String, Integer> sub = formulaRealization.Sub(100, true, 5); for (String s : sub.keySet()) {System.out.print(s+"="+sub.get(s)+" ");}}@TestSystem.out.print(s+"="+mul.get(s)+" ");}}@Testpublic void testDiv() {Map<String, String> div = formulaRealization.Div(100, true, true, 5);for (String s : div.keySet()) {System.out.print(s+"="+div.get(s)+" ");}}@Testpublic void test1() {String div = formulaRealization.fracReduction(25,5);System.out.print(div);}}(4)IFileGenerationpackage cn.zhl.fileCreate;import java.util.Map;public interface IFileGeneration {//⽤于将产⽣的算式写⼊到⽂件中public void fileShow(Map<String,?> stringMap,int lineNum,String fileName); }(5)FileRealizationpackage cn.zhl.fileCreate;import java.io.File;import java.io.FileWriter;import java.io.IOException;@Overridepublic void fileShow(Map<String,?> stringMap, int lineNum, String fileName) {int n=0;String answerName=fileName+"_Answer.txt";fileName=fileName+".txt";/*File file1 = new File("\\cn\\zhl\\formulaFile\\" + fileName);File file2 = new File("\\cn\\zhl\\formulaFile\\" + answerName);*/File file1 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+fileName);File file2 = new File("Arithmetic_question_generation_system\\src\\cn\\zhl\\formulaFile\\"+answerName);for (String s : stringMap.keySet()) {n++;try(FileWriter formulaWriter = new FileWriter(file1,true); FileWriter answerWriter = new FileWriter(file2,true)) { formulaWriter.write(s+"= ");answerWriter.write(s+"="+stringMap.get(s)+" ");if(n%lineNum==0){formulaWriter.write("\n");answerWriter.write("\n");}} catch (IOException e) {e.printStackTrace();System.out.println("未成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,请联系开发⼈员!"); }}System.out.println("已成功将算式保存到"+fileName+"中,答案保存到"+answerName+"中,欢迎您的下次使⽤!"); }}(6)FormulaCustomTestpackage cn.zhl.software;import cn.zhl.fileCreate.FileRealization;import java.io.File;import java.io.FileWriter;import java.io.IOException;public class FormulaCustomTest {public static void main(String[] args) {int formulaNum;boolean if_MulDiv;int range;boolean ifNeg_AddSub;boolean ifRem_Div;boolean ifRed_Div;int lineNum;Scanner scanner = new Scanner(System.in);System.out.println("请输⼊需要算式个数:");formulaNum=scanner.nextInt();System.out.println("请输⼊需要乘除法(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){if_MulDiv=true;}else {if_MulDiv=false;}System.out.println("请输⼊需要结果集范围(默认-n~n):");range=scanner.nextInt();System.out.println("请输⼊允许加减法出现负数(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifNeg_AddSub=true;}else {ifNeg_AddSub=false;}System.out.println("请输⼊允许除法出现⼩数(Y/N):");if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRem_Div=true;}else {ifRem_Div=false;}System.out.println("请输⼊允许除法结果换算成分数(Y/N):"); if(scanner.next().equals("y")||scanner.next().equals("Y")){ifRed_Div=true;}else {lineNum=scanner.nextInt();//⽂件名String fileName="";System.out.println("请输⼊算式需要导⼊的⽂件名:");fileName=scanner.next();System.out.println("定制完成,正在随机⽣成算式。

javaweb编写四则运算

javaweb编写四则运算

javaweb编写四则运算⾸先先画出⼀个表<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>四则运算</title></head><form name="a1" action="chuti.jsp" onsubmit="return check(a1);"><h2 align="center">四则运算</h2><table align="center"border="2" width="400"><body><tr><td>你想要的题⽬数量</td><td><input type="text" name="number" value=""placeholder="题数"onchange="checkti(a1)"></td></tr><tr><td>你想要的题⽬的每⾏个数</td><td><input type="text" name="hang" value=""placeholder="⾏数"onchange="checkhang(a1)"></td></tr><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table><script type="text/javascript">function check(a1){var num = a1.number.value;var hang= a1.hang.value;if(num.length==0){alert("题数不能为空");a1.number.value="";a1.number.focus();return false;}if(num.length==0){alert("⾏数不能为空");a1.number.value="";a1.number.focus();return false;}}function checkti(a1){var num = a1.number.value;if(num==""){alert("题数不能为空");a1.number.value="";a1.number.focus();return false;}}function checkhang(a1){var hang=a1.hang.value;if(hang.length==0){alert("⾏数不为空");a1.hang.value="";a1.hang.focus();return false;} 其中运⽤了script语句进⾏脚本判断,来初始判断你输进来的值然后我做了⼀个出题界⾯<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>答题界⾯</title></head><%int h=Integer.parseInt(request.getParameter("hang"));int n=Integer.parseInt(request.getParameter("number"));String value[]=new String[n];String answer[]=new String[n];int i;for(i=0;i<n;){int num1=(int)(1+(Math.random()*100));int num2=(int)(1+(Math.random()*100));int f=(int)(1+(Math.random()*4));if(f==1){value[i]=num1+"+"+num2+"=";answer[i]=num1+num2+"";i++;}else if(f==2&&num1>=num2){value[i]=num1+"-"+num2+"=";answer[i]=num1-num2+"";i++;}else if(f==3&&num1*num2<100){value[i]=num1+"*"+num2+"=";answer[i]=num1*num2+"";i++;}else if(f==4&&num2!=0&&num1%num2==0){value[i]=num1+"/"+num2+"=";answer[i]=num1/num2+"";i++;}elsecontinue;}%><body><h2 align="center">练习题</h2><form action="panduan.jsp"><table align="center"border="2" width="400"><%int k;for(int j=0;j<n;){k=0;%><tr><%while(k<h){%><td><%=value[j] %></td><td><input type="hidden" name="value" value=<%=value[j] %>></td><td><input type="text" name="result" /></td><td><input type="hidden" name="answer" value=<%=answer[j] %>></td> <%j++;k++;if(j>=n)break;}%></tr><%}%><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table></form></body></html> 然后设计⼀个后台来对程序进⾏判断<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>答题界⾯</title></head><%int h=Integer.parseInt(request.getParameter("hang"));int n=Integer.parseInt(request.getParameter("number"));String value[]=new String[n];String answer[]=new String[n];int i;for(i=0;i<n;){int num1=(int)(1+(Math.random()*100));int num2=(int)(1+(Math.random()*100));int f=(int)(1+(Math.random()*4));if(f==1){value[i]=num1+"+"+num2+"=";answer[i]=num1+num2+"";i++;}else if(f==2&&num1>=num2){value[i]=num1+"-"+num2+"=";answer[i]=num1-num2+"";i++;}else if(f==3&&num1*num2<100){value[i]=num1+"*"+num2+"=";answer[i]=num1*num2+"";i++;}else if(f==4&&num2!=0&&num1%num2==0){value[i]=num1+"/"+num2+"=";answer[i]=num1/num2+"";i++;}elsecontinue;}%><body><h2 align="center">练习题</h2><form action="panduan.jsp"><table align="center"border="2" width="400"><%int k;for(int j=0;j<n;){k=0;%><tr><%while(k<h){%><td><%=value[j] %></td><td><input type="hidden" name="value" value=<%=value[j] %>></td><td><input type="text" name="result" /></td><td><input type="hidden" name="answer" value=<%=answer[j] %>></td> <%j++;k++;if(j>=n)break;}%></tr><%}%><tr><td colspan="2" align="center"><input type="submit" value="提交"></td></tr></table></form></body></html> 最后⼀个结束界⾯<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><!DOCTYPE html><html><head><meta charset="UTF-8"><title>结束界⾯</title></head><body>本次答题结束</body></html>。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《程序设计实践》题目:小学生四则运算练习程序
学校:
学院:
班级:
学号:
姓名:_
2014 年11月24 日
实践基础程序设计实践
一、实践目的
1、掌握基本输入输出。

2、掌握方法定义与调用,理解参数传递方式。

二、实践要求
利用方法、数组、基本输入输出等Java基础知识,给出所选项目的基本设计与实现。

三、项目需求
所选项目名称:小学生四则运算练习程序
实现对小学生简单加法、减法、乘法、除法的四则运算练习。

要求通过键盘输入两个运算数,并回显输入数,将运算结果输出。

四、项目设计方案
Test类:
数据域:sum,总分数。

方法:core()负责随机生成题目,并对其打上分数。

main(String[] args)是程序的入口,负责程序的开始。

五、核心算法详细设计
1.public static void main(String[] args) {
Test t = new Test();
// 提示用户考试信息
System.out.println("本次测试共十道题,每题十分,满分一百分");
// 将分数sum初始化为0;
t.sum = 0;
// 创建一个随机类
Random r = new Random();
// 进行10个循环,对应着10道题
for (int i = 0; i < 10; i++) {
t.core();
}
//打印出考试成绩
System.out.println(" 考试结束");
System.out.println(" 您的总分为" + t.sum);
}
2.//考试的题目。

private void core() {
//产生一个随即生成器
Random r = new Random();
//产生一个在0,1,-1之中的数
int m, n;
m = r.nextInt() % 10;
n = m % 2;
六、完整源码
package test;
import java.util.Random;
import java.util.Scanner;
public class Test {
int sum;
public static void main(String[] args) {
Test t = new Test();
// 提示用户考试信息
System.out.println("本次测试共十道题,每题十分,满分一百分");
// 将分数sum初始化为0;
t.sum = 0;
// 创建一个随机类
Random r = new Random();
// 进行10个循环,对应着10道题
for (int i = 0; i < 10; i++) {
t.core();
}
//打印出考试成绩
System.out.println(" 考试结束");
System.out.println(" 您的总分为" + t.sum);
}
//考试的题目。

private void core() {
//产生一个随即生成器
Random r = new Random();
//产生一个在0,1,-1之中的数
int m, n;
m = r.nextInt() % 10;
n = m % 2;
switch (n) {
//如果n为-1,则进行加法运算
case -1:
int a,b,c;
//a为操作数,b为被操作数,都是10以内的数字。

a = r.nextInt() % 10;
b = r.nextInt() % 10;
//给出运算式,让用户输入答案
System.out.println(a + "+" + "(" + b + ")=?");
Scanner x = new Scanner(System.in);
c = x.nextInt();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (c != a + b)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
//如果n为0,则进行乘法运算
case 0:
int q,w,e;
//q为操作数,w为被操作数,都是10以内的数字。

q = r.nextInt() % 10;
w = r.nextInt() % 10;
//给出运算式,让用户输入答案
System.out.println(q + "*" + "(" + w + ")" + "=?");
Scanner y = new Scanner(System.in);
e = y.nextInt();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (e != q * w)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
//如果n为1,则进行除法运算
case 1:
double j,k,l;
//j为操作数,k为被操作数,都是10以内的数字。

j = r.nextInt() % 10;
k = r.nextInt() % 10;
//k作为被除数不能为0
if (k == 0)
k++;
//给出运算式,让用户输入答案
System.out.println(j + "/" + "(" + k + ")" + "=?");
Scanner z = new Scanner(System.in);
l = z.nextDouble();
//判断用户的答案正确与否,若正确则加10分,错误就只提示错误
if (l != (j / k) / 1.00)
System.out.println("回答错误");
else {
System.out.println(" 回答正确");
sum = sum + 10;
}
break;
}
}
}
七、使用说明与运行结果截图
1.运行程序,出现提示页面,弹出第一个题目
2.
2.输入结果“-1”,单击回车,提示回答正确,弹出下一题
3.输入结果“-5”,单击回车,提示正确,弹出下一题
4.输入错误答案“53”,提示错误
5.输入结果“7”,单击回车,弹出下一题。

6.继续做题,直到完成10道计算,在此不一一阐述
7. 当10道题目做完结束后,显示最终成绩
八、实践总结
本次实践是第一次实践,自己的基本功不扎实就更要努力了,老师说了这个学期的实践对于自己的动手能力和以后的学习都很有帮助,所以我也下定决心好好学,这个程序自己打的很累,其中张昊给了我很大的帮助,结果还算满意,不过还有不足,也希望自己能够在今后越做越好,能够提高自己,也希望老师能更加督促我,成绩能有一个大的进步。

[此文档可自行编辑修改,如有侵权请告知删除,感谢您的支持,我们会努力把内容做得更好]。

相关文档
最新文档