精华内容
下载资源
问答
  • 主要介绍了Java实现中文算数验证码的实现示例(算数运算+-*/),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java算数运算符详解

    2020-09-28 15:04:02
    Java运算符分为算数运算符、关系运算符、逻辑运算符、位运算符,而今天要详细讲的是算数运算符 算数运算符(9):+ - * / % ++ -- 关系运算符(6):== != > >= < <= 逻辑运算符(6):&& || ! ^ &...

    Java运算符分为算数运算符、关系运算符、逻辑运算符、位运算符,而今天要详细讲的是算数运算符

    算数运算符(9):+  -  *  /  %  ++  --

    关系运算符(6):==  !=  >  >=  <  <=

    逻辑运算符(6):&&  ||  !  ^  &  |

    位运算符(7):&  |  ~  ^  >>  <<  >>>;

    一:算数运算符:

    注:算数运算符操作数必须是数值类型。

    分为一元运算符和二元运算符;

    一元运算符,只有一个操作数;

    二元运算符有两个操作数,运算符在两个操作数之间。

    一元运算符:正‘+’,负‘-’,自加‘++’,自减‘--‘这四个。

    ①”++“和”--“运算符,只允许用于数值类型的变量,不允许用于表达式中;

        "++"和”--“可以用于数值变量之前或者之后;

        两处使用差别:

               ”++“和”--“用于数值变量之前,在赋值操作中,先对被”++“或”--“操作变量值先加1或者先减1,然后在进行其他的操作;

               "++"和”--“用于数值变量之后,在赋值操作中,先用被”++“或”--“的操作变量值进行其他的操作,然后在对其值加1或者减1。

    package com.lai;
    
    public class demo {
    	public static void main(String[] args) {
    		int a = 5;
    		int b, c, d, f, g, h;
    		b = +a; // 正值
    		System.out.println("b=" + b + ",a=" + a);
    		c = -a; // 负值
    		System.out.println("c=" + c + ",a=" + a);
    		int l = 2;
    		d = ++l; // 先l=l+1;再d=l
    		System.out.println("d=" + d + ",l=" + l);
    		int m = 3;
    		f = m++;// 先f=m;再m=m+1
    		System.out.println("f=" + f + ",m=" + m);
    		int n = 4;
    		g = --n;// 先n=n-1;再g=n
    		System.out.println("g=" + g + ",n=" + n);
    		int o = 6;
    		h = o--;// 先h=o;再o=o-1
    		System.out.println("h=" + h + ",o=" + o);
    	}
    }

    输出的结果为:

    b=5,a=5

    c=-5,a=5

    d=3,l=3

    f=3,m=4

    g=3,n=3

    h=6,o=5

    注:一元运算符和前后的操作数之间有空格,可能在有些编译器下编译时会出错。

    二元运算符,加'+'减'-'乘'*'除'/'求余'%'

    在算数运算符中,”+“,”-“,”*“,”/“完成加减乘除四则运算,%是求两个操作数相除后的余数。

    运算规则和数学运算基本相同,在算数运算中,计算时按照从左向右的顺序计算,乘除和求余优先于加减,不同的是,程序中的乘运算符不可省略,在数学中可写为”y=2x“而程序中必须写为”y=2*x“。

    当二元运算的两个操作数的数据类型不同时,运算结果的数据类型和参与运算的操作数的数据类型中精度较高(或位数较长)一致。

    展开全文
  • " } } } 4.2 运行界面实现 一、算数运算测试 二、猜数游戏 5结论和心得 结论:算术运算测试、猜数游戏让我对java程序有了更深的了解,同时也很圆满的完成了该项目 心得:回顾知识点的同时也增加了新知识数据库以及...
     
    

    1 选题

    选题一

    算术运算测试

    题目要求

    实现十道100以内加减法数学题,能根据题目计算出答案,与输入答案对比,判断做题是否正确,最后计算分数。每道题10分,答对得10分,答错不得分。最后计算成绩为多少分。

    1. 沟通表达能力;
    2. 资料搜集能力;
    3. 自主学习能力;
    4. 时间规划能力;
    5. 独立完成项目能力;
    6. 文档撰写能力;

    面向对象编程思维和软件工程思想。

    使用Java知识

    Java基本输入输入出、运算符、循环、选择分支; JDBC,数据库,mysql。 

    选题二

    猜数游戏

    题目要求

    计算机产生随机数,猜中即胜,猜不中,提示是大了还是小了,继续猜,直至猜到,给出所用时间和评语。保留用户测试成绩,做出成绩排行榜。排行榜存放到文件或数据库中。

    1.沟通表达能力;

    2.资料搜集能力;

    3.自主学习能力;

    4.时间规划能力;

    5.独立完成项目能力;

    6.文档撰写能力;

    面向对象编程思维和软件工程思想。

    使用Java知识

    循环、分支、变量、判断、常用类等; JDBC。


    2 系统需求分析

    2.1 系统可行性分析

    一、算数运算测试

    1.技术可行性

    本次程序运用的是Eclipse这个软件,采用的JAVA语言,JAVA面向对象,所以技术上是可行的。

    2.经济可行性

    因为本次程序使用的Eclipse软件是免费的,在这个软件上就能满足我们的需求,不需要额外的开销所以经济上也是可行的。

    3.操作可行性

    本次程序只需要用户有这个软件并配置好环境变量并且安装windowbuilder插件就可以使用,操作简单便捷,符合大部分用户的使用习惯。因此在操作上是可行的。

    4.法律可行性

    在法律许可范围内。

    2.2 系统需求分析

    1.通过与老师和同学交流,完成了简单的运算算数测试,实现了十道100以内加减法数学题,根据题目算出答案,与用户输入答案对比,判断做题是否正确,若正确,则分数加10分,若答错,则不加分,最后计算分数总和,每道题10分,共计100分。

    2.功能模块图

    图2-1 算数测试运算模块图

                                                    

    图2-2 猜数游戏模块图

    2.3进度安排

    阶段一进度安排如表3-1所示。

    表3-1 进度安排表

    阶段

    持续时间

    阶段描述

    输出

    构思阶段

    2小时

    需求分析

    需求说明,功能模块图

    设计阶段

    2小时

    系统设计

    设计说明-可以画流程图;数据库设计

    实现阶段

    3小时

    编写代码

    项目工程源代码

    3小时

    系统测试

    进行黑盒测试(功能测试)-测试说明

    运行阶段

    4小时

    部署、运行

    系统使用说明、运维报告、录制视频


    3 系统设计

    3.1 系统设计

    一、算数测试运算

    根据系统的实际功能需求分析,对系统功能部分进行了设计。

    随机测试题目生成模块:先随机生成2个数,随机生成运算符号+或者-。

    题目测试模块:输入得数,判断所输入得数与正确答案是否相等。若正确,则输出正确进行下一道题目,若错误,则输出正确答案并进行下一道题目。

    成绩记录模块:每道题10分,一共十道题,总共100分。

    二、猜数游戏

    根据系统的实际功能需求分析,对系统功能部分进行了设计。

    随机数输入模块:程序运行后,会自动获取一个随机数,也就是说系统会随机生成一个数,这个数就是我们要猜的数。

    次数记录模块:每猜一次就会记录一次,记录总次数。

    大小判断模块:每次猜测的数字,若大于随机数,则会提示您的结果大于随机数,若小于数,则会提示您的结果小于随机数。否则退出判断,输出猜对了

    4 系统实现

    4.1 代码实现

    算数运算测试

    功能的基本要求:实现十道100以内加减法数学题,能根据题目计算出答案,与输入答案对比,判断做题是否正确,最后计算分数。每道题1分,答对得1分,答错不得分。最后计算成绩为多少分。

    package com.su;

    import java.util.*;

    import java.io.File;

    import java.io.FileWriter;

    import java.io.BufferedWriter;

    import java.io.IOException;

    import com.mysql.jdbc.Connection;

    import java.sql.DriverManager;

    import com.mysql.jdbc.Statement;

    import java.sql.ResultSet;

    import java.sql.SQLException;

    public class SuanShu {

    private static java.sql.Statement statement;

    public static void main(String[]args){

     Scanner input=new Scanner(System.in);

     //计算分数

     int count=0;

     int num=0;

     String name = null;

     //生成随机数a b

     System.out.println("请输入有多少人进行测试");

     int  peoplenumber=input.nextInt();

     for(int i=0;i<peoplenumber;i++)//测试人数

     {

      count=0;//循环一次后将答对次数清0

      System.out.println("你是第"+(i+1)+"位进行算数测试的人");

      System.out.println("输入姓名:");

     name=input.next();

      for(int j=0;j<1;j++)//循环输出10道题

      {

       int m=(int)(Math.random()*100);

       int n=(int)(Math.random()*100);//随机生成两个随机数

       if(m<=n)

       {

        System.out.println("第"+(j+1)+"道题为:"+m+"+"+n);//如果a>b就相加

        num=m+n;

       }else{

        System.out.println("第"+(j+1)+"道题为:"+m+"-"+n);//如果a<b就想减

        num=m-n;

       }

       System.out.println("请输入答案:");

       int DaAn=input.nextInt();

       if(DaAn==num)//令正确答案和用户输入答案相比较

       {

        System.out.println("回答正确!");

        count++;

       }else{

        System.out.println("回答错误,正确答案是"+num);

       }

      }

      System.out.println("您得得分为:"+count);

     }

     input.close();

    /*-----------------------------------------------------------------------------------*/

     Connection con;

    String driver="com.mysql.jdbc.Driver";

    String url="jdbc:mysql://localhost:3306/mysql";

    String user="root";

    String password="root";

    try{

    Class.forName(driver);

    con =  (Connection) DriverManager.getConnection(url, user, password);

    if(!con.isClosed())

    System.out.println("Sucess");

    //增加数据

    String sql1 = "insert into suanshu values("+count+",'"+name+"')";

    //statement = null;

    statement.executeUpdate(sql1);

    //查询数据

    String sql = "select * from suanshu";

    ResultSet rs=statement.executeQuery(sql);

    System.out.println("------------");

    System.out.println("姓名"+"\t"+"成绩");

    System.out.println("------------");

    String name1 = null;

    while(rs.next()){

    name1=rs.getString("name");

    //int  score=rs.getInt("score");

    //System.out.println(name1 + "\t"+score);

    System.out.println(name1);

    }

    rs.close();

    con.close();

    }catch(ClassNotFoundException e){

    System.out.println("Sorry");

    e.printStackTrace();

    }catch(SQLException e){

    e.printStackTrace();

    }catch(Exception e){

    e.printStackTrace();

    }finally{

    System.out.println("数据库成功获取");

    }

       }

    }

    二、猜数游戏

    功能的基本要求:计算机产生随机数,猜中即胜,猜不中,提示是大了还是小了,继续猜,直至猜到,给出所用时间和评语。保留用户测试成绩,做出成绩排行榜。

     package com.su;

    import java.io.FileWriter;

    import java.util.Arrays;

    import java.util.Scanner;

    public class CaiShu {

     public static void main(String[] args){

       

      Scanner input=new Scanner(System.in);

       

      int count=0;//猜测次数

      int guess;//用户猜测的数

         long startTime=0,endTime=0;//开始时间和结束时间

        System.out.println("******欢迎来到猜数游戏******");

        System.out.println("请输入测试人数:");

        int peoplenumble=input.nextInt();

        for(int i=0;i<peoplenumble;i++)//测试人数

        {

         count=0;//当第2个人开始测试时,前面的猜测次数清0

         int number=(int)(Math.random()*100);//生成100之内的随机

         System.out.println("您是第"+(i+1)+"位进行猜数游戏的人");

         System.out.println("请输入姓名:");

         String name =input.next();

         startTime=System.currentTimeMillis();//开始时间

         System.out.println("请猜一个1到100之间的整数");

         guess=input.nextInt();//进行猜测

         count++;//每循环一次猜测次数+1

        

        do{

         if(guess>number)

         {

          System.out.println("猜错了,您的结果偏大,可以再继续猜");//判断大小

          guess=input.nextInt();

          count++;

         }

         if(guess<number)

         {

          System.out.println("猜错了,您的结果偏小,可以再继续猜");//判断大小

          guess=input.nextInt();

          count++;

         }

        }while(guess!=number);

         endTime=System.currentTimeMillis();//结束时间

         System.out.println("恭喜您猜对了!");

         System.out.println("您一共猜了"+count+"次,耗时"+(endTime-startTime)/1000+"秒");

         if(count<=1)

          System.out.println("真棒一次就猜对了!");//当一次就猜对时输出"真棒一次就猜对了!"

         if(1<count&&count<=5)

          System.out.println("不错哦!");//当2到5次就猜对时输出"不错哦!"

         if(5<count)

          System.out.println("还需努力哦!");//当5次以上猜对时输出"还需努力哦!"

        }

        }

      }

    4.2 运行界面实现

    算数运算测试

         

    二、猜数游戏

    5结论和心得

    结论:算术运算测试、猜数游戏让我对java程序有了更深的了解,同时也很圆满的完成了该项目

    心得:回顾知识点的同时也增加了新知识数据库以及mysql和GUI的学习阶段1较短时间使我对数据库这方面感到自身水平的不总,但是我也在不断地学习和改进,与同学和老师的交流使我受益匪浅,我会慢慢提升自己,,即使学习路上会遇到很多困难和挫折,但也不会阻止我学习的道路。

    展开全文
  • 产品提出的需求:根据mtmCode表达式计算该操作步骤的工时,mtmCode为operationCode的组合(该组合为算数表达式),根据该表达式计算该操作的工时: 此处举一个建单的例子 此处直接上代码: package ...

    产品提出的需求:根据mtmCode表达式计算该操作步骤的工时,mtmCode为operationCode的组合(该组合为算数表达式),根据该表达式计算该操作的工时:  此处举一个建单的例子

     

    此处直接上代码:

     

    package com.nio.portal.common.util;
    
    /**
     * @Title: ArithHelper
     * @Description: TODO
     * @author lulu.wang.o
     * @version V1.0
     * @date 2019-11-19
     */
    public class ArithHelper {
    
            // 默认除法运算精度
            private static final int DEF_DIV_SCALE = 16;
            // 这个类不能实例化
            private ArithHelper() {
            }
            /**
             * 提供精确的加法运算。
             *
             * @param v1 被加数
             * @param v2 加数
             * @return 两个参数的和
             */
            public static double add(double v1, double v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
                java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
                return b1.add(b2).doubleValue();
            }
            public static double add(String v1, String v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
                java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
                return b1.add(b2).doubleValue();
            }
            /**
             * 提供精确的减法运算。
             *
             * @param v1 被减数
             * @param v2 减数
             * @return 两个参数的差
             */
            public static double sub(double v1, double v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
                java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
                return b1.subtract(b2).doubleValue();
            }
            public static double sub(String v1, String v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
                java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
                return b1.subtract(b2).doubleValue();
            }
            /**
             * 提供精确的乘法运算。
             *
             * @param v1
             *      被乘数
             * @param v2
             *      乘数
             * @return 两个参数的积
             */
            public static double mul(double v1, double v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
                java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
                return b1.multiply(b2).doubleValue();
            }
            public static double mul(String v1, String v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
                java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
                return b1.multiply(b2).doubleValue();
            }
            /**
             * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后10位,以后的数字四舍五入。
             *
             * @param v1
             *      被除数
             * @param v2
             *      除数
             * @return 两个参数的商
             */
            public static double div(double v1, double v2) {
                return div(v1, v2, DEF_DIV_SCALE);
            }
            public static double div(String v1, String v2) {
                java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
                java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
                return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
            }
            /**
             * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 定精度,以后的数字四舍五入。
             *
             * @param v1 被除数
             * @param v2 除数
             * @param scale 表示表示需要精确到小数点以后几位。
             * @return 两个参数的商
             */
            public static double div(double v1, double v2, int scale) {
                if (scale < 0) {
                    throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
                }
                java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
                java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
                return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
            }
            /**
             * 提供精确的小数位四舍五入处理。
             *
             * @param v 需要四舍五入的数字
             * @param scale 小数点后保留几位
             * @return 四舍五入后的结果
             */
            public static double round(double v, int scale) {
                if (scale < 0) {
                    throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
                }
                java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
                java.math.BigDecimal one = new java.math.BigDecimal("1");
                return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
            }
            public static double round(String v, int scale) {
                if (scale < 0) {
                    throw new IllegalArgumentException("The  scale  must  be  a  positive  integer  or  zero");
                }
                java.math.BigDecimal b = new java.math.BigDecimal(v);
                java.math.BigDecimal one = new java.math.BigDecimal("1");
                return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
            }
    
    
            public static void main(String[] args) {
                String expression = "(3+5)*6-3";
                double result = TaskTimeCalculator.conversion(expression);
                System.out.println(expression + " = " + result);
                System.out.println();
            }
        }

     

     

    package com.nio.portal.common.util;
    
    import java.util.Collections;
    import java.util.Stack;
    
    /**
     * @Title: TaskTimeCalculator
     * @Description: 算数表达式求值,直接调用Calculator的类方法conversion(),传入算数表达式,将返回一个浮点值结果,如果计算过程错误,将返回一个NaN
     * @author lulu.wang.o
     * @version V1.0
     * @date 2019-11-19
     */
    
    public class TaskTimeCalculator {
    
        private Stack<String> postfixStack = new Stack<String>();
        // 后缀式栈
        private Stack<Character> opStack = new Stack<Character>();
        // 运算符栈
        private int[] operatPriority = new int[]{0, 3, 2, 1, -1, 1, 0, 2};
    
        // 运用运算符ASCII码-40做索引的运算符优先级
        public static double conversion(String expression) {
            double result = 0;
            TaskTimeCalculator cal = new TaskTimeCalculator();
            try {
                expression = transform(expression);
                result = cal.calculate(expression);
            } catch (Exception e) {
                // e.printStackTrace();
                // 运算错误返回NaN
                return 0.0 / 0.0;
            }
            // return new String().valueOf(result);
            return result;
        }
    
        /**
         *  * 将表达式中负数的符号更改
         *  *
         *  * @param expression
         *  *  例如-2+-1*(-3E-2)-(-1) 被转为 ~2+~1*(~3E~2)-(~1)
         *  * @return
         *  
         */
        private static String transform(String expression) {
            char[] arr = expression.toCharArray();
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == '-') {
                    if (i == 0) {
                        arr[i] = '~';
                    } else {
                        char c = arr[i - 1];
                        if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'E' || c == 'e') {
                            arr[i] = '~';
                        }
                    }
                }
            }
    
            if (arr[0] == '~' || arr[1] == '(') {
                arr[0] = '-';
                return "0" + new String(arr);
            } else {
                return new String(arr);
            }
        }
    
        /**
         *  * 按照给定的表达式计算
         *  *
         *  * @param expression
         *  *  要计算的表达式例如:5+12*(3+5)/7
         *  * @return
         *  
         */
        public double calculate(String expression) {
            Stack<String> resultStack = new Stack<String>();
            prepare(expression);
            Collections.reverse(postfixStack);
            // 将后缀式栈反转
            String firstValue, secondValue, currentValue;
            // 参与计算的第一个值,第二个值和算术运算符
            while (!postfixStack.isEmpty()) {
                currentValue = postfixStack.pop();
                //不是运算符
                if (!isOperator(currentValue.charAt(0))) {
                    // 如果不是运算符则存入操作数栈中
                    currentValue = currentValue.replace("~", "-");
                    resultStack.push(currentValue);
                } else {
                    // 如果是运算符则从操作数栈中取两个值和该数值一起参与运算
                    secondValue = resultStack.pop();
                    firstValue = resultStack.pop();
                    // 将负数标记符改为负号
                    firstValue = firstValue.replace("~", "-");
                    secondValue = secondValue.replace("~", "-");
                    String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
                    resultStack.push(tempResult);
                }
            }
            return Double.valueOf(resultStack.pop());
        }
    
        /**
         *  * 数据准备阶段将表达式转换成为后缀式栈
         *  *
         *  * @param expression
         *  
         */
        private void prepare(String expression) {
            opStack.push(',');
            // 运算符放入栈底元素逗号,此符号优先级最低
            char[] arr = expression.toCharArray();
            int currentIndex = 0;
            // 当前字符的位置
            int count = 0;
            // 上次算术运算符到本次算术运算符的字符的长度或者之间的数值
            char currentOp, peekOp;
            // 当前操作符和栈顶操作符
            for (int i = 0; i < arr.length; i++) {
                currentOp = arr[i];
                if (isOperator(currentOp)) {
                    // 如果当前字符是运算符
                    if (count > 0) {
                        postfixStack.push(new String(arr, currentIndex, count));
                        // 取两个运算符之间的数字
                    }
                    //返回栈顶元素
                    peekOp = opStack.peek();
                    if (currentOp == ')') {
                        // 遇到反括号则将运算符栈中的元素移除到后缀式栈中直到遇到左括号
                        while (opStack.peek() != '(') {
                            postfixStack.push(String.valueOf(opStack.pop()));
                        }
                        opStack.pop();
                    } else {
                        while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
                            postfixStack.push(String.valueOf(opStack.pop()));
                            peekOp = opStack.peek();
                        }
                        opStack.push(currentOp);
                    }
                    count = 0;
                    currentIndex = i + 1;
                } else {
                    count++;
                }
            }
            if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {
                // 最后一个字符不是括号或者其他运算符的则加入后缀式栈中
                postfixStack.push(new String(arr, currentIndex, count));
            }
            while (opStack.peek() != ',') {
                postfixStack.push(String.valueOf(opStack.pop()));
                // 将操作符栈中的剩余的元素添加到后缀式栈中
            }
        }
    
        /**
         *  * 判断是否为算术符号
         *  *
         *  * @param c
         *  * @return
         *  
         */
        private Boolean isOperator(char c) {
            return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
        }
    
        /**
         *  * 利用ASCII码-40做下标去算术符号优先级
         *  *
         *  * @param cur
         *  * @param peek
         *  * @return
         *  
         */
        public Boolean compare(char cur, char peek) {
    // 如果是peek优先级高于cur,返回true,默认都是peek优先级要低
            Boolean result = false;
            if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
                result = true;
            }
            return result;
        }
    
        /**
         *  * 按照给定的算术运算符做计算
         *  *
         *  * @param firstValue
         *  * @param secondValue
         *  * @param currentOp
         *  * @return
         *  
         */
        private String calculate(String firstValue, String secondValue, char currentOp) {
            String result = "";
            switch (currentOp) {
                case '+':
                    result = String.valueOf(ArithHelper.add(firstValue, secondValue));
                    break;
                case '-':
                    result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
                    break;
                case '*':
                    result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
                    break;
                case '/':
                    result = String.valueOf(ArithHelper.div(firstValue, secondValue));
                    break;
            }
            return result;
        }
    }

     

    展开全文
  • Java算数运算符(+ - * / % -- ++)

    千次阅读 2019-01-24 11:56:14
    * 算数运算符 */ @Test public void test1(){ int a=3,b=2; System.out.println(&amp;quot;=====加法(+)=====&amp;quot;); System.out.print(&amp;quot;3+2=&amp;quot;); System.out....
    	/**
    	 * 算数运算符
    	 */
    	public void test1() {
    		int a = 3, b = 2;
    		System.out.println("=====加法(+)=====");
    		System.out.print("3+2=");
    		System.out.println(a + b);
    
    		System.out.println("=====减法(-)=====");
    		System.out.print("3-2=");
    		System.out.println(a - b);
    
    		System.out.println("=====乘法(*)=====");
    		System.out.print("3*2=");
    		System.out.println(a * b);
    
    		System.out.println("=====除法(/)=====");
    		System.out.print("a/b=");
    		System.out.println(a / b);
    
    		System.out.println("=====取余(%)=====");
    		// 3取余2剩1,5取余2=1,规律:除尽后的余数
    		System.out.print("a%b=");
    		System.out.println(a % b);
    
    		System.out.println("=====自增(a++)=====");
    		// 先运算然后再自增++的数值是1;
    		System.out.print("a++=");
    		System.out.println(a++);
    
    		System.out.println("=====自增(++a)=====");
    		// 先自增再运算
    		System.out.print("++a=");
    		System.out.println(++a);
    
    		System.out.println("=====自减(a--)=====");
    		// 先运算再自减
    		System.out.print("a--=");
    		System.out.println(a--);
    
    		System.out.println("=====自减(--a)=====");
    		// 先自减再运算
    		System.out.print("--a=");
    		System.out.println(--a);
    
    		System.out.println("验证自增执行顺序(自减同理)");
    		System.out.println("=====(a++)=====");
    		int c = a++;
    		System.out.println("先将a的值赋值给c:" + c);
    		System.out.println("赋值给c后a的值是+1后的结果a:" + a);
    		// 这样就验证了a++是先被使用,使用完成后自身+1。
    
    		System.out.println("=====(++a)=====");
    		int d = ++a;
    		System.out.println("先看下a的结果:" + a);
    		System.out.println("a先+1然后赋值给d:" + d);
    		// 这样验证了++a是先自身+1然后在赋值其他变量。
    		//在输出时没有使用()来进行优先级输出是为了考虑有些不太懂的人,下几篇文章会介绍。
    	}
    	
    
    
        输出结果:
        =====加法(+)=====
        3+2=5
        =====减法(-)=====
        3-2=1
        =====乘法(*)=====
        3*2=6
        =====除法(/)=====
        a/b=1
        =====取余(%)=====
        a%b=1
        =====自增(a++)=====
        a++=3
        =====自增(++a)=====
        ++a=5
        =====自减(a--)=====
        a--=5
        =====自减(--a)=====
        --a=3
        验证自增执行顺序(自减同理)
        =====(a++)=====
        先将a的值赋值给c:3
        赋值给c后a的值是+1后的结果a:4
        =====(++a)=====
        先看下a的结果:5
        a先+1然后赋值给d:5
    
    
    展开全文
  • java算数运算符

    2018-11-03 22:06:42
    常见的算数运算符: + 求和 - 相减 * 乘积 / 相除 ++ 自加1 -- 自减1 % 取余、求模 例子: int a = 20; int b = 3; System.out.println(a+b); //23 System.out.println(a-b); //17 System.out.println(a*b); /...
  • java算数题--水仙花

    2020-03-16 17:40:22
    水仙花数 // 输入100到999之间的三位数字,判断...import java.util.Scanner; public class ccc { public static void main(String args[]){ Scanner sc=new Scanner (System. in); System. out. println( "输...
  • JAVA算数验证码

    2018-05-25 14:45:50
    package ... import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt...
  • demo导入eclipse直接可用,中文并有算数运算,并且可验证用户输入值,还有详细说明文档,简单易懂
  • 计算成绩的平均数和总数 // An highlighted block import java.util.Scanner; public class chengji { public static void main(String args[]){ Scanner sc=new Scanner(System.in); System.out.println...
  • Java算数运算符就是运用数学运算,操纵变量。 ‘+’ :加法 ‘- ’:减法 ‘*’ :乘法 / :除法 % :取余 ++ :自增 – :自减 注意:自增、自减在前面后面位置是有区别的。 例如: ++y(–y):指的是y先自增(自减...
  • Java中的运算符算数运算符(9个)+ 加号 - 减号 * 乘号 / 除号 % 取余 ++ 自增 -- 自减 关系运算符(6个)== 等于,返回boolean值,判断两边是否相等。如果两边相等则返回true,如果两边不想等则返回false > 大于,返回...
  • 小学算术运算测试程序,JAVA课程设计报告,有基本代码
  • Java算数运算符

    2019-09-05 19:12:03
    算数运算符 赋值运算符 比较运算符 逻辑运算符 条件运算符 位运算符 操作数: 运算符左右两边连接的数 表达式: 运算符连接左右两边的操作数叫做表达式 语句 : ;代表语句的结束 单目|一元运算符 : 操作数...
  • 022- Java算数运算符

    2019-09-28 12:44:11
    算数运算符有哪些: 输入以下代码: public class Operator01 { public static void main(String[]args){ int a = 10; int b = 3; int c = a+b; int d = a-b; ...
  • 所以右边界、左边界、和中间值(即guessNum)都可以赋为int类型没有问题,但是当中间值相乘超过int的范围时,虽然要被赋予的值得类型是long,相乘的结果仍然会变成负数,因为int和int进行算数运算,结果仍然是int,并...
  • java算数运算符之加法

    千次阅读 2017-10-13 19:01:15
    public class Test07{ public static void main...//算数运算符 System.out.println("1+2="+(1+2)); System.out.println("1+1="+1+1); /* "1+2="+(1+2) 运算1:1+2 结果: 3 运算2:"1+2="+3 结果: "1+2=3"
  • intm=1intn=2intsum=m+++++n-n-----m+n-----m最后m等于几n等于几
  • JAVA的运算符,分为四类:算数运算符、关系运算符、逻辑运算符、位运算符算数运算符(9):+ - * / % ++ --关系运算符(6):== != &gt; &gt;= &lt; &lt;=逻辑运算符(6):&amp;&amp; || ! ^ &...
  • /:除法 %:余数 举个例子: Scanner sc = new Scanner(System.in); System.out.println("请输入四位数:"); int num = sc.nextInt(); //千位上的数 int n1 = num/1000; //百位上的数 int n2 = num/100%10;...System
  • int x =(5*8/(7+2)) % 5; 正确结果是x=4 我第一步算的是 5*8 结果是40 第二步是5*8/(7+2)结果是4余4 第三步(5*8/(7+2)) % 5就搞不明白了 怎么得到的4?
  • * 1、算数运算符 */ public static void main(String[] args) { // TODO 自动生成的方法存根 int x = 4; int y = 3; System.out.print("加法运算"); System.out.println(x+y); System.out.print...
  • Java中的算数运算

    千次阅读 2018-05-12 12:02:58
    运算符的分类: 算数运算符 , 赋值运算符 , 比较运算符 , 逻辑运算符 , 三元运算符算数运算符包括: + 加法运算,字符串连接运算 - 减法运算 * 乘法运算 / 除法运算 % 取模运算,两个数字相除取余数(又称...
  • java算数运算之除法与取余

    千次阅读 2017-10-13 19:07:18
    public class Test09{ public static void main(String[] args){ System.out.println("--除法---------------------------------------------------"); System.out.println("5/2="+(5/2));// 整数 / 整数 == 整数 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,898
精华内容 11,159
关键字:

java算数

java 订阅