精华内容
下载资源
问答
  • 新手小白学JAVA 初识JAVA运算符

    万次阅读 多人点赞 2021-03-31 21:46:30
    java语言中,运算符可分为5种类型: 算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。 根据操作数的不同,运算符又分为单目运算符、双目运算符和三目运算符。 单目运算符只有一个操作数,双目运算符有...

    1 运算符

    1.1 概述

    运算符 用于连接 表达式 的 操作数,并对操作数执行运算。
    例如,表达式num1+num2,其操作数是num1和num2,运算符是”+”。
    在java语言中,运算符可分为5种类型:
    算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
    根据操作数的不同,运算符又分为单目运算符、双目运算符和三目运算符。
    单目运算符只有一个操作数,双目运算符有两个操作数,三目运算符则有三个操作数。
    位运算符涉及到二进制位的运算,在java 程序中运用不是很多。

    1.2 运算符速查表

    运算符速查表

    1.3 练习:测试自增自减

    创建包: cn.tedu.basic
    创建类: TestOperator.java

    package cn.tedu.basic;
    /**本类用于测试取余运算符*/
    public class TestOperator {
    	//0.创建程序的入口函数main Alt+/补全代码
    	public static void main(String[] args) {
    		/**基本的四则运算符+ - * / */
    		//1.测试除法与取余数
    		System.out.println(25/10);//int/int->int,商是2
    		System.out.println(25%10);//取余,余数为5
    		//练习:获取一个两位数的十位与个位
    		int x = 59;
    		System.out.println(59/10);//获取十位,包含几个10
    		System.out.println(59%10);//获取个位,除十位之外还剩多少
    		//练习:获取一个三位数的百位 十位 与个位
    		int y = 152;
    		System.out.println(y / 100);//获取百位,包含几个100
    		System.out.println(y / 10 % 10);//获取十位,15个十,取余取5
    		System.out.println(y % 10);//获取个位,除了15个10以外的余数2
    		
    		//2.测试自增自减运算符
    		/**前缀式:++a --a,先改变变量的值,再使用
    		 *    后缀式: a++ a--,先使用,再改变变量的值
    		 * ++:表示给当前变量的值+1
    		 * --:表示给当前变量的值-1*/
    		System.out.println("我是一个无情的分界线");
    		int a = 1;
    		System.out.println(a++);//1,符号在后,先使用,再自增
    		System.out.println(a);//2,使用过后自增成2
    		
    		int b = 1;
    		System.out.println(++b);//2,符号在前,先自增,再使用
    		
    		int c = 1;
    		System.out.println(--c);//0,符号在前,先自减,再打印
    		
    		int d = 1;
    		System.out.println(d--);//1,符号在后,先打印,再自减
    		System.out.println(d);//0,刚刚使用过后就自减
    		
    		/**之前的代码会对后面的代码产生影响*/
    		System.out.println(c);//c的初始值是0
    		/**只有自增自减运算符才会改变变量本身的值
    		 * 普通的四则运算只能改变算式本身的值*/
    		System.out.println(--c-c-c--);//-1-(-1)-(-1)=1
    		//System.out.println(c);//-2	
    	}
    }
    
    

    1.4 练习:求两数的最大值

    创建包: cn.tedu.basic
    创建类: TestMaxNum.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**需求:接收用户输入的两个整数,并比较输出这两个数的最大值*/
    public class TestMaxNum {
    	public static void main(String[] args) {
    		//1.提示用户输入
    		System.out.println("请输入您要比较的第一个整数:");
    		//2.接收用户输入的整数,并把这个值交给变量a来保存
    		int a = new Scanner(System.in).nextInt();
    		System.out.println("请输入您要比较的第二个整数:");
    		int b = new Scanner(System.in).nextInt();
    		
    		//3.比较接收两个数,使用三元运算符
    		/**1 ? 2 : 3
    		 * 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
    		 * */
    		//4.定义变量max来保存比较的最大值
    		int max = a > b ? a : b;
    		
    		//5.打印最大值
    		System.out.println("两个数的最大值是:"+max);	
    		/**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/
    	}
    }
    

    1.5 练习:求平年闰年

    创建包: cn.tedu.basic
    创建类: TestYear.java

    需求:接收用户输入的年份,判断是平年还是闰年
    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**
     * 需求:接收用户输入的年份,判断是平年还是闰年
     * 如果年份是闰年,需要满足下面两个条件之一:
     * 条件1:能被4整除,并且不能被100整除
     * 条件2:能被400整除
     * */
    public class Test3_Year {
    	public static void main(String[] args) {
    		//1.提示并接收用户输入的年份
    		System.out.println("请输入您要判断的年份:");
    		int year = new Scanner(System.in).nextInt();
    		
    		//2.定义一个变量用来保存结果
    		String result = "平年";//默认值是平年,假设每年都是平年
    		
    		//3.判断用户输入的年份是否满足闰年的条件
    		/**解决方案1*/
    		/**条件1:能被4整除,并且不能被100整除*/
    //		if(year % 4 == 0) {//能被4整除
    //			if(year %100 != 0) {//不能被100整除
    //				result = "闰年";//符合闰年的条件1,修改结果为闰年
    //			}
    //		}
    //		/**条件2:能被400整除*/
    //		if(year % 400 == 0) {//能被400整除
    //			result = "闰年";//符合闰年的条件2,修改结果为闰年
    //		}
    		/**解决方案2*/
    		/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
    		//if(条件1  || 条件2){是闰年 }
    		//if((小条件1  && 小条件2) || 条件2){ 是闰年 }
    		//if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }
    		if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){
    			result = "闰年";//符合闰年的条件,修改结果为闰年
    		}
    		System.out.println(year+"年是"+result);
    	}
    	
    }
    

    2 拓展补充:

    2.1 总结1:算术运算符之自增自减运算符

    a是操作数,++是自增运算符,–是自减运算符,自增和自减运算符即可以放在变量的前面,也可以放在变量的后面,例如:a++、++a、a–、--a等。
    自增(++):将变量的值加1
    分前缀式(如++a)和后缀式(如a++)。前缀式是先加1再使用;后缀式是先使用再加1。
    自减(–):将变量的值减1
    分前缀式(如–a)和后缀式(如a–)。前缀式是先减1再使用;后缀式是先使用再减1。

    2.2 总结2:逻辑运算符

    逻辑运算符连接两个关系表达式或布尔变量,用于解决多个关系表达式的组合判断问题
    注意逻辑运算符返回的运算结果为布尔类型
    通常,我们用0表示false,用1表示true
    与:表示并且的关系
    &单与: 1 & 2 ,结果想要是true,要求1和2都必须是true
    &&双与(短路与):1 && 2 ,当1是false时,2会被短路,提高程序的效率
    或:表示或者的关系
    |单或: 1 | 2,结果想要是true,要求1和2只要有一个为true就可以
    ||双或(短路或):1 || 2,当1是true时,2会被短路,提高程序效率

    2.3 总结3:优先级控制

    当一个表达式包含多个运算符时,就需要考虑运算符的优先级,优先级高的运算符先参与运算,优先级低的运算符后参与运算。在实际的开发中,不需要特别去记忆运算符的优先级别,也不要刻意的使用运算符的优先级别,对于不清楚优先级的地方使用小括号辅助进行优先级管理。

    展开全文
  • JAVA——运算符

    2021-01-30 20:46:08
    表达式:用运算符把常量或者变量连接起来符合Java语法的式子,不同运算符连接的表达式体现的是不同类型的表达式。 1.2 算术运算符 注意事项: /和%的区别:两个数据做除法,/取结果的商,%取结果的余数。 整数操作...

    运算符

    1. 算术运算符
      1.1 运算符和表达式
      运算符:对常量或者变量进行操作的符号。
      表达式:用运算符把常量或者变量连接起来符合Java语法的式子,不同运算符连接的表达式体现的是不同类型的表达式。
      1.2 算术运算符
      在这里插入图片描述
      注意事项:
      /和%的区别:两个数据做除法,/取结果的商,%取结果的余数。
      整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。
      1.3 字符的“+”操作
      拿字符在计算机底层对应的数值来进行计算的。
      在这里插入图片描述
      算术表达式中包含多个基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。
      提升规则:
      (1)byte类型,short类型和char类型将被提升到int类型。
      (2)整个表达式的类型自动提升到表达式中最高等级操作数同样的类型。
      等级顺序:byte、short、char—>int—>long—>float—>double
      1.4 字符串的“+”操作
      当“+”操作中出现字符串时,这个“+”是字符串连接符,而不是运算符。
      在“+”操作中,如果出现了字符串,就是链接运算符,否则就是算数运算,当连续进行“+”操作时,从左到右逐个执行。
    2. 赋值运算符
      2.1 赋值运算符
      在这里插入图片描述
      注意事项:
      扩展的运算符隐含了强制类型转换。
    3. 自增自减运算符
      3.1 自增自减运算符
      在这里插入图片描述
      注意事项:
      (1)++和–既可以放在变量的后边,也可以放在变量的前边。
      (2)单独使用的时候,++和–无论是放在变量的前边还是后边,结果是一样的。
      (3)参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者–;参与操作的时候,如果放在变量的前边,先拿变量做++或者–,后拿变量参与操作。
    4. 关系运算符
      4.1 关系运算符
      在这里插入图片描述
      注意事项:
      (1)关系运算符的结果都是boolean类型,要不是true,要么是false。
      (2)不要把“==”写成“=”。
    5. 逻辑运算符
      5.1 逻辑运算符概述
      逻辑运算符,是用来连接关系表达式的运算符,逻辑运算符可以直接连接布尔类型的常量或者变量。
      5.2 逻辑运算符
      在这里插入图片描述
      5.3 短路逻辑运算符
      在这里插入图片描述
      注意事项:
      (1)逻辑与&,无论左边真假,右边都要执行;短路与&&,如果左边为真,右边执行,如果左边为假,右边不执行。
      (2)逻辑或|,无论左边真假,右边都要执行;短路或||,如果左边为假,右边执行,如果左边为真,右边不执行。
    6. 三元运算符
      6.1 三元运算符
      格式:关系表达式?表达式1:表达式2;
      范例:a>b?a:b;
      计算规则:
      首先计算关系表达式的值,如果值为true,表达式1的值就是运算结果;如果值为false,表达式2的值就是运算结果。
    展开全文
  • Java运算符

    2018-03-24 14:00:11
    Java运算符运算符,顾名思义,用来操作整数基本类型的二进制位。它直接与底层硬件进行操作,所以效率比较高。一般可以将位运算符分成两类:按位运算符和移位运算符。凡是有一定计算机基础的人,都知道上面的...

    Java位运算符

    位运算符,顾名思义,用来操作整数基本类型的二进制位。它直接与底层硬件进行操作,所以效率比较高。一般可以将位运算符分成两类:按位运算符和移位运算符。凡是有一定计算机基础的人,都知道上面的概念和运算规则。但是接下来的这个移位运算操作就不是所有人都知道它的概念了。
    这里写图片描述
    注意到>>>操作没?很明显,它应该是一个右移运算符,但是它比平常的右移运算符多了一个>符合。由此,引出了Java中的“无符号”右移运算符概念。“有符号”右移运算符即>>在运算时,若操作数是正数,则高位补0;若操作数是负数,则高位补1。而“无符号”右移运算符即>>>在运算时,无论正负数,都在高位补0。示例:
    -10>>1结果将会是-5,由于Java中int类型固定长度为32,因此运算过程如下:
    -10的原码为:1000 +24个0 + 1010
    -10的反码为:1111 + 24个1 + 0101
    -10的补码为:1111 + 24个1 + 0110
    计算机的运算都是在补码的基础上运算,-10的补码右移1位,变成:1111 + 24个1 + 1011,这么大个数是负数的补码,换算成原码恰好是-5。
    -10>>>1结果是2147483643,结果会这么大自然是无符号右移运算时在高位补0造成的。运算过程大概如下:
    -10 的补码无符号右移1为,变成:0111 + 24个1 + 1011,而正数的补码与原码相同,计算结果最终就是2147483643。
    上述“无符号”右移操作是Java特有的,C中没有。下面的位运算则是通用的。
    按位运算符操作整数基本类型的某一二进制位(bit)。

    &——与操作

    将运算符两侧的整数按照二进制位进行‘与’运算符。规则是:仅当两个二进制位都为1时,结果为1;有一个不为1,结果就为0。示例:
    12的二进制表示为1100,5的二进制表示为0101,那么12&5=4。

    |——或操作

    规则是:仅当两个二进制位都为0时,结果为0,有一个为1结果就为1。示例:
    12的二进制表示为1100,5的二进制表示为0101,那么12|5=13。

    ^——异或操作

    规则是:仅当两个二进制位都为1时,结果为0,有一个为1结果就是1。示例:
    12的二进制表示为1100,5的二进制表示为0101,那么12^5=9。

    ~——取反操作

    规则是:0变成1,1变成0。示例:12的二进制为1100,那么~12=-13。注意是按照补码进行取反的。

    <<——左移操作

    规则是:将操作数往左移,低位补0。
    12<<1结果是24。-12<<1结果是-24。

    PS:上面图片中的代码是JDK1.8中HashMap初始化容量时调用的方法,其作用是将给定数的二进制有效位全部置为1,也就是说通过这个tableSizeFor(int n)方法,得到比n大的最近的一个2次幂数。其原理大概是运用了或操作|的置1性,即1|1=1,1|0=1。

    展开全文
  • Java-运算符

    2020-10-21 15:56:47
    文章目录1. 运算符1.1 算术运算符(理解)1.1.1 运算符和表达式1.1.2 算术运算符1.1.3 字符的“+”操作1.1.4 字符串的“+”操作1.2 ...表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

    1. 运算符

    1.1 算术运算符(理解)

    1.1.1 运算符和表达式

    运算符:对常量或者变量进行操作的符号

    表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

    ​ 不同运算符连接的表达式体现的是不同类型的表达式。

    举例说明:

    int a = 10;
    int b = 20;
    int c = a + b;
    

    +:是运算符,并且是算术运算符。

    a + b:是表达式,由于+是算术运算符,所以这个表达式叫算术表达式。

    1.1.2 算术运算符

    符号 作用 说明
    + 参看小学一年级
    - 参看小学一年级
    * 参看小学二年级,与“×”相同
    / 参看小学二年级,与“÷”相同
    % 取余 获取的是两个数据做除法的余数

    注意:

    /和%的区别:两个数据做除法,/取结果的商,%取结果的余数。

    整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。

    int a = 10;
    int b = 3;
    System.out.println(a / b); // 输出结果3
    System.out.println(a % b); // 输出结果1
    

    1.1.3 字符的“+”操作

    char类型参与算术运算,使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值:

    ‘a’ – 97 a-z是连续的,所以’b’对应的数值是98,'c’是99,依次递加

    ‘A’ – 65 A-Z是连续的,所以’B’对应的数值是66,'C’是67,依次递加

    ‘0’ – 48 0-9是连续的,所以’1’对应的数值是49,'2’是50,依次递加

    // 可以通过使用字符与整数做算术运算,得出字符对应的数值是多少
    char ch1 = 'a';
    System.out.println(ch1 + 1); // 输出98,97 + 1 = 98
    
    char ch2 = 'A';
    System.out.println(ch2 + 1); // 输出66,65 + 1 = 66
    
    char ch3 = '0';
    System.out.println(ch3 + 1); // 输出49,48 + 1 = 49
    

    算术表达式中包含不同的基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。

    提升规则:

    byte类型,short类型和char类型将被提升到int类型,不管是否有其他类型参与运算。

    整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

    ​ 等级顺序:byte,short,char --> int --> long --> float --> double

    例如:

    byte b1 = 10;
    byte b2 = 20;
    // byte b3 = b1 + b2; // 该行报错,因为byte类型参与算术运算会自动提示为int,int赋值给byte可能损失精度
    int i3 = b1 + b2; // 应该使用int接收
    byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
    -------------------------------
    int num1 = 10;
    double num2 = 20.0;
    double num3 = num1 + num2; // 使用double接收,因为num1会自动提升为double类型
    

    tips:正是由于上述原因,所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符,而使用字符串类型,更不会使用char类型做算术运算。

    1.1.4 字符串的“+”操作

    当“+”操作中出现字符串时,这个”+”是字符串连接符,而不是算术运算。

    System.out.println("itheima"+ 666); // 输出:itheima666
    

    在”+”操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行“+”操作时,从左到右逐个执行。

    System.out.println(1 + 99 + "年黑马"); // 输出:100年黑马
    System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出:3itheima34
    // 可以使用小括号改变运算的优先级 
    System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出:3itheima7
    

    1.2 赋值运算符(应用)

    赋值运算符的作用是将一个表达式的值赋给左边,左边必须是可修改的,不能是常量。

    符号 作用 说明
    = 赋值 a=10,将10赋值给变量a
    += 加后赋值 a+=b,将a+b的值给a
    -= 减后赋值 a-=b,将a-b的值给a
    *= 乘后赋值 a*=b,将a×b的值给a
    /= 除后赋值 a/=b,将a÷b的商给a
    %= 取余后赋值 a%=b,将a÷b的余数给a

    注意:

    扩展的赋值运算符隐含了强制类型转换。

    short s = 10;
    s = s + 10; // 此行代码报出,因为运算中s提升为int类型,运算结果int赋值给short可能损失精度
    
    s += 10; // 此行代码没有问题,隐含了强制类型转换,相当于 s = (short) (s + 10);
    

    1.3 自增自减运算符(理解)

    符号 作用 说明
    ++ 自增 变量的值加1
    自减 变量的值减1

    注意事项:

    ​ ++和-- 既可以放在变量的后边,也可以放在变量的前边。

    ​ 单独使用的时候, ++和-- 无论是放在变量的前边还是后边,结果是一样的。

    ​ 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者–。

    ​ 参与操作的时候,如果放在变量的前边,先拿变量做++或者–,后拿变量参与操作。

    ​ 最常见的用法:单独使用。

    int i = 10;
    i++; // 单独使用
    System.out.println("i:" + i); // i:11
    
    int j = 10;
    ++j; // 单独使用
    System.out.println("j:" + j); // j:11
    
    int x = 10;
    int y = x++; // 赋值运算,++在后边,所以是使用x原来的值赋值给y,x本身自增1
    System.out.println("x:" + x + ", y:" + y); // x:11,y:10
    
    int m = 10;
    int n = ++m; // 赋值运算,++在前边,所以是使用m自增后的值赋值给n,m本身自增1
    System.out.println("m:" + m + ", m:" + m); // m:11,m:11
    

    练习:

    int x = 10;
    int y = x++ + x++ + x++;
    System.out.println(y); // y的值是多少?
    /*
    解析,三个表达式都是++在后,所以每次使用的都是自增前的值,但程序自左至右执行,所以第一次自增时,使用的是10进行计算,但第二次自增时,x的值已经自增到11了,所以第二次使用的是11,然后再次自增。。。
    所以整个式子应该是:int y = 10 + 11 + 12;
    输出结果为33。
    */
    注意:通过此练习深刻理解自增和自减的规律,但实际开发中强烈建议不要写这样的代码!小心挨打!
    

    1.4 关系运算符(应用)

    关系运算符有6种关系,分别为小于、小于等于、大于、等于、大于等于、不等于。

    符号 说明
    == a==b,判断a和b的值是否相等,成立为true,不成立为false
    != a!=b,判断a和b的值是否不相等,成立为true,不成立为false
    > a>b,判断a是否大于b,成立为true,不成立为false
    >= a>=b,判断a是否大于等于b,成立为true,不成立为false
    < a<b,判断a是否小于b,成立为true,不成立为false
    <= a<=b,判断a是否小于等于b,成立为true,不成立为false

    注意事项:

    ​ 关系运算符的结果都是boolean类型,要么是true,要么是false。

    ​ 千万不要把“”误写成“=”,"“是判断是否相等的关系,”="是赋值。

    int a = 10;
    int b = 20;
    System.out.println(a == b); // false
    System.out.println(a != b); // true
    System.out.println(a > b); // false
    System.out.println(a >= b); // false
    System.out.println(a < b); // true
    System.out.println(a <= b); // true
    
    // 关系运算的结果肯定是boolean类型,所以也可以将运算结果赋值给boolean类型的变量
    boolean flag = a > b;
    System.out.println(flag); // 输出false
    

    1.5 逻辑运算符(应用)√√√√√√√

    逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断的结果是 true 或 false。

    符号 作用 说明
    & 逻辑与 a&b,a和b都是true,结果为true,否则为false
    | 逻辑或 a|b,a和b都是false,结果为false,否则为true
    ^ 逻辑异或 a^b,a和b结果不同为true,相同为false
    ! 逻辑非 !a,结果和a的结果正好相反
    //定义变量
    int i = 10;
    int j = 20;
    int k = 30;
    
    //& “与”,并且的关系,只要表达式中有一个值为false,结果即为false
    System.out.println((i > j) & (i > k)); //false & false,输出false
    System.out.println((i < j) & (i > k)); //true & false,输出false
    System.out.println((i > j) & (i < k)); //false & true,输出false
    System.out.println((i < j) & (i < k)); //true & true,输出true
    System.out.println("--------");
    
    //| “或”,或者的关系,只要表达式中有一个值为true,结果即为true
    System.out.println((i > j) | (i > k)); //false | false,输出false
    System.out.println((i < j) | (i > k)); //true | false,输出true
    System.out.println((i > j) | (i < k)); //false | true,输出true
    System.out.println((i < j) | (i < k)); //true | true,输出true
    System.out.println("--------");
    
    //^ “异或”,相同为false,不同为true
    System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
    System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
    System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
    System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
    System.out.println("--------");
    
    //! “非”,取反
    System.out.println((i > j)); //false
    System.out.println(!(i > j)); //!false,,输出true
    

    短路逻辑运算符****

    符号 作用 说明
    && 短路与 作用和&相同,但是有短路效果
    || 短路或 作用和|相同,但是有短路效果

    在逻辑与运算中,只要有一个表达式的值为false,那么结果就可以判定为false了,没有必要将所有表达式的值都计算出来,短路与操作就有这样的效果,可以提高效率。同理在逻辑或运算中,一旦发现值为true,右边的表达式将不再参与运算。

    • 逻辑与&,无论左边真假,右边都要执行。

    • 短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。

    • 逻辑或|,无论左边真假,右边都要执行。

    • 短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。

    int x = 3;
    int y = 4;
    System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
    System.out.println(x); // 4
    System.out.println(y); // 5
    
    System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false,右边不参与运算
    System.out.println(x); // 4
    System.out.println(y); // 4
    

    1.6 三元运算符(理解)

    三元运算符语法格式:

    关系表达式 ? 表达式1 : 表达式2;
    

    解释:问号前面的位置是判断的条件,判断结果为boolean型,为true时调用表达式1,为false时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式1,否则执行第二个。

    举例:

    int a = 10;
    int b = 20;
    int c = a > b ? a : b; // 判断 a>b 是否为真,如果为真取a的值,如果为假,取b的值
    

    三元运算符案例:

    1、需求:动物园里有两只老虎,已知两只老虎的体重分别为180kg、200kg,请用程序实现判断两只老虎的体重是否相同。

    public class OperatorTest01 {
    	public static void main(String[] args) {
    		//1:定义两个变量用于保存老虎的体重,单位为kg,这里仅仅体现数值即可。
    		int weight1 = 180;
    		int weight2 = 200;	
    		//2:用三元运算符实现老虎体重的判断,体重相同,返回true,否则,返回false。
    		boolean b = weight1 == weight2 ? true : false;	
    		//3:输出结果
    		System.out.println("b:" + b);
    	}
    }
    

    2、需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm、210cm、165cm,请用程序实现获取这三个和尚的最高身高。

    public class OperatorTest02 {
    	public static void main(String[] args) {
    		//1:定义三个变量用于保存和尚的身高,单位为cm,这里仅仅体现数值即可。
    		int height1 = 150;
    		int height2 = 210;
    		int height3 = 165;	
    		//2:用三元运算符获取前两个和尚的较高身高值,并用临时身高变量保存起来。
    		int tempHeight = height1 > height2 ? height1 : height2;		
    		//3:用三元运算符获取临时身高值和第三个和尚身高较高值,并用最大身高变量保存。
    		int maxHeight = tempHeight > height3 ? tempHeight : height3;	
    		//4:输出结果
    		System.out.println("maxHeight:" + maxHeight);
    	}
    }
    

    2. 数据输入(应用)√√√√√√√

    我们可以通过 Scanner 类来获取用户的输入。使用步骤如下:

    1、导包。Scanner 类在java.util包下,所以需要将该类导入。导包的语句需要定义在类的上面。

    import java.util.Scanner; 
    

    2、创建Scanner对象。

    Scanner sc = new Scanner(System.in);// 创建Scanner对象,sc表示变量名,其他均不可变
    

    3、接收数据

    int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
    

    示例:

    import java.util.Scanner;
    public class ScannerDemo {
    	public static void main(String[] args) {
    		//创建对象
    		Scanner sc = new Scanner(System.in);
    		//接收数据
    		int x = sc.nextInt();
    		//输出数据
    		System.out.println("x:" + x);
    	}
    }
    

    改写三个和尚案例,数据使用键盘录入。

    import java.util.Scanner;
    public class ScannerTest {
    	public static void main(String[] args) {
    		//身高未知,采用键盘录入实现。首先导包,然后创建对象。
    		Scanner sc = new Scanner(System.in);
    		//键盘录入三个身高分别赋值给三个变量。
    		System.out.println("请输入第一个和尚的身高:");
    		int height1 = sc.nextInt();
    		System.out.println("请输入第二个和尚的身高:");
    		int height2 = sc.nextInt();
    		System.out.println("请输入第三个和尚的身高:");
    		int height3 = sc.nextInt();
    		//用三元运算符获取前两个和尚的较高身高值,并用临时身高变量保存起来。
    		int tempHeight = height1 > height2 ? height1 : height2;
    		//用三元运算符获取临时身高值和第三个和尚身高较高值,并用最大身高变量保存。
    		int maxHeight = tempHeight > height3 ? tempHeight : height3;
    		//输出结果。
    		System.out.println("这三个和尚中身高最高的是:" + maxHeight +"cm");
    	}
    }
    
    展开全文
  • java算术运算符

    2019-11-28 10:16:44
    算术运算符用于执行程序中的数学运算,JAVA 中常用的算术运算符有以下 5 种: +加或正值 -减或负值 *乘 / 除 % 取余 (1) 加法或者正值运算符“+”。作为加法运算符时是双目运算符,也就是需要有 2 个 操作数参与运算...
  • java 换行 运算符格式 上周,我发现了什么决定了我在较长时间里一直在努力解决的问题的决定:是否放置&& , ||之类的运算符 或+在同一行或下一行。 在构造布尔表达式或隐含字符串时,我们可能需要中断...
  • java三元运算符

    2021-01-09 21:06:40
    三元运算符 一元运算符:只需要一个数据就可进行操作的运算符。...1.必须同时保证表达式A和B都符合左侧数据类型的要求 2.三元运算符的结果必须被使用 int a = 10; int b = 20; //数据类型 变量名称 = 条件判
  • Java三元运算符

    2020-11-04 20:17:44
    /* 一元运算符:只需要一个数据就可以进行操作的运算符。例如:取反!、自增++、自减– 二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+、赋值= ...1.必须同时保证表达式A和表达式B都符合左侧数据类型的要
  • java三目运算符

    万次阅读 2018-01-12 15:49:18
    写在前面: 三目运算符是我们经常在代码中使用的,a= (b=...前段时间遇到(一个由于使用三目运算符导致的问题,其实是因为有三目运算符和自动拆箱同时使用(虽然自动拆箱不是我主动用的)。 一、三目运算符 对于条
  • Java关系运算符

    千次阅读 2017-01-08 21:44:46
    关系运算符他得出的值就只有这两个值,true和false简单的说他就是用来做判断的,判断选择之间是否符合要求,如果符合那就是真或者对,不符合要求那就为假或者错,真为true来代表,假为false来代表。
  • Java算术运算符

    2017-01-06 21:22:44
    大家都知道什么是算术运算符他就是数学中的 + - * / 除了这些之外java中还有一种算术运算符:% 取余(取膜) % 他可以叫取余也可以说是取膜两种叫法都可以。那他是用来干什么的?
  • JAVA语言运算符

    2016-07-01 11:33:06
    原文  ...   JAVA语言运算符 编辑 锁定 Java,是由Sun Microsystems公司于1995年5月推出的Java
  • Java运算符

    2020-04-09 17:40:58
    运算符:进行特定操作的符号,例如 + 表达式:用运算符连起来的式子叫做表达式 例如 a + b 算术运算符: 加减乘除 + - * / 取模(取余数)% :对于整数的表达式来说,除法用的是整除,整数除以整数,结果也是是整数...
  • 赋值运算符“=”,是 JAVA 中使用最多的运算符,作用是将一个值(字面量值、变量值、 表达式计算结果)复制一份给另一个变量。赋值运算符常见形式: 变量 = 表达式; a = 1+1; //先计算表达式 1+1,然后将结果值赋给...
  • java语言运算符

    2016-09-03 16:04:00
    组成表达式的Java操作符有很多种。运算符按照其要求的操作数数目来分,可以有单目运算符、双目运算符和三目运算符,它们分别对应于1个、2个、3个操作数。运算符按其功能来分,有算术运算符、赋值运算符、关系运算符...
  • java逻辑运算符

    2017-01-06 21:03:03
    什么是逻辑运算符?就是让我们的条件多组合在一起,一次组合多个条件,然后再运算最后的逻辑值是否满   足要求,说白了逻辑运算符就是多个选择或者多个要求。逻辑运算符有:&amp;&amp;(与) ||(或) !(非)...
  • 运算符把常量或者变量连接起来符合java语法的式子; 不同类型运算符连接的式子体验的是不同类型的表达式 常用运算符: 算术运算符; 自增自减运算符; 赋值运算符; 关系运算符; 逻辑运算符; 三元运算符 算术...
  • Java——运算符

    2019-04-11 11:52:45
    今天我们学习了运算符、键盘录入数据、流程控制语句。 运算符剩下的还有逻辑运算符、位运算符、三元运算符。 一、逻辑运算符 ...在Java中我们要表示一个数大于3并且小于6 ,不可以写成3<x<6,应...
  • 逻辑运算符的基本用法 * 逻辑运算符有哪些 * &amp;,|,^,!... * b:表达式:就是用运算符把常量或者变量连接起来的符合java语法的式子。 * 算术表达式:a + b * 比较表达式:a == b(条件表达式)...
  • Java,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台的...介绍Java运算符,以及区分JAVA语言与C语言中运算符的差异。 基本信息 中文名称 JAVA语言运算符 推出 Sun Microsyste..
  • Java三目运算符

    2017-11-20 13:47:41
    一、三目运算符 对于条件表达式b?x:y,先计算条件b,然后进行判断。如果b的值为true,计算x的值,运算结果为x的值;否则,计算y的值,运算结果为y的值。一个条件表达式从不会既计算x,又计算y。条件运算符是右...
  • java赋值运算符简介

    2019-10-14 22:46:08
    二、符合赋值运算符: 1、a+=5:相当于 a=a+5; 2、a-=5:相当于 a=a-5; 3、a*=5:相当于 a=a*5; 4、a/=5:相当于 a=a/5; 5、a%=5:相当于 a=a%5. 赋值运算符的注意事项: 1、赋值预算只在变量中使用,常量是不能...
  • java-运算符

    2019-05-18 16:53:00
    运算符 简述 对常量和变量进行操作的符号 算术运算符(6种) +, -, *, /, %, ++, -- 说明: %的应用场景,判断两个数是否整除; 字符串参与的加法操作是字符串拼接; ++,--运算符:对变量做加1或者减1的...
  • Java运算符

    2021-08-01 23:48:42
    算数运算符(Arithmetic operator) 关系运算符(Relational operator) 逻辑运算符(Logical operator) 赋值运算符(Assignment Operators) 三元运算符(Ternary operator) 运算符优先级 标识符的命名规则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,294
精华内容 16,117
关键字:

java符合运算符

java 订阅