Java中各种运算符（算术、增减、赋值、关系、逻辑、条件）及表达式内容优先级的详细解析。

运算符

概述

针对常量和变量之间进行运算的符号
例如: a + 1 ,a + b, a / b. a > b 其中 + / > 就是运算符

运算符的分类

算术运算符 赋值运算符 关系运算符 逻辑运算符 位运算符(了解) 三目运算符

算数运算符

算术运算符: + - * / %

• 在Java当中含义很多
    1.作为正数
    2.加法运算
    3.字符串连接符

如何分离中一个数的每一位
  将1234这个数分离每一位
  分离个位: 1234 / 1 % 10
  分离十位: 1234 / 10 % 10
  分离百位: 1234 / 100 % 10
  分离千位: 1234 / 1000 % 10

代码示例

public class OperatorDemo01 {
	public static void main(String[] args){
		System.out.println(+5); // 5
		System.out.println(2+5); // 7
		System.out.println("2"+5); // 25
		System.out.println(2-5); // -3
		System.out.println(2*5); // 10
		System.out.println((double)2/5); // 0
		System.out.println(2%5); // 2
		
		int num = 1234;
		int ge = num / 1 % 10;
		int shi = num / 10 % 10;
		int bai = num / 100 % 10;
		int qian = num / 1000 % 10;
		System.out.println(num + "," + ge + "," + shi + "," + bai + "," + qian);	
	}
}

自增自减运算符 ++ –

++ – 属于单目运算符

++ 表示自增1
– 表示自减1

分为
  单独使用
   表示自增或者自减,没有任何区别
  参与运算
   如果++放在操作数的左边,就表示先自增再参与运算
   如果++放在操作数的右边,就表示先参与运算,再自增或者自减1

代码示例

public class OperatorDemo02 {
	public static void main(String[] args){
		int a = 3;
		int b = 4;
		
		System.out.println("a=" + a + ",b=" + b);
		
		// 单独使用
		// a++;
		// b--;
		++a; // 4
		--b; // 3
		System.out.println("a=" + a + ",b=" + b);
		
		// int c = ++a;
		// int d = --b; 
		// a=5,b=2,c=5,d=2 
		int c = a++;
		int d = b--; 
		// a=5,b=2,c=4,d=3
		System.out.println("a=" + a + ",b=" + b + ",c=" + c + ",d=" + d); 

	}
}

赋值运算符

= : 这个等于号在Java中表示赋值的意思,真正数学意义上的相等是 ==,在JavaScript中还有 ===

扩展赋值运算符: += 、-= 、*=、 /= 、%=
例如 a += 10; 在计算结果上等同于 a=a+10;

short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错??
   前者编译失败,short和int类型计算结果是int类型,将int类型赋值给short类型,需要强制类型转换
   后者编译通过,因为使用扩展赋值运算符系统会自动帮我们强制类型转换

技巧: 如何交换两个数? ==>可以定义中间变量temp

代码示例

public class OperatorDemo04 {
	public static void main(String[] args){
		// 将常量10赋值给变量a [运算过程: 从右往左]
		int a = 10;
		// 二次赋值
		a = 20;
		
		a += 30; // 等同于 a = a + 30; 50
		System.out.println(a);
		a -= 10; // 等同于 a = a - 10; 40
		System.out.println(a);
		a *= 10; // 400
		System.out.println(a);
		a /= 10; // 40
		System.out.println(a);
		a %= 10; // 0
		System.out.println(a);
		
		short s1 = 1; 
		// s1 = s1 + 1; // 不兼容的类型: 从int转换到short可能会有损失
		s1 += 1; // s1 = (short)(s1 + 1);
		System.out.println(s1);
		
		// 如何交换两个数?
		int x = 100;
		int y = 200;
		
		System.out.println("交换前: x = " + x + ",y= " + y);
		int temp = 0;
		temp = y;
		y = x;
		x = temp;
		System.out.println("交换后: x = " + x + ",y= " + y);
	}
}

关系运算符

关系运算符有 > < >= <= != ==
注意: 关系运算符参与比较运算的结果必须是boolean类型

代码示例

public class OperatorDemo05 {
	public static void main(String[] args){
		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); // true
		System.out.println(a==b); // false
		System.out.println(a!=b); // true	
	}
}

逻辑运算符

作用: 用于连接多个boolean类型的表达式
格式: boolean类型的表达式1 逻辑运算符 boolean类型的表达式2 逻辑运算符 boolean类型的表达式3
逻辑运算符有 &&、||、!

逻辑关系: 与 或 非 异或
与: 类似于串联电路，如果两边同时成立，结果成立，有一个不成立，结果不成立
或: 类似于并联电路，如果两边同时不成立，结果不成立，有一个成立，结果成立
非: 与原来结果相反
异或: 类似于恋爱关系【同性相斥，异性相吸】，如果两边不同，则结果成立，如果两边相同，则结果不成立

其实具备逻辑关系的除了有逻辑运算符还有位运算符，
虽然 &、|、^、~【取反】 属于位运算符，不是逻辑运算符但是有逻辑关系
其中&【按位与】, |【按位或】, ^【按位异或】也可以和连接多个boolean类型的表达式
而&&【短路与】, ||【短路或】,!【非】属于逻辑运算符，只能够进行逻辑运算不能够进行位运算。

与 &&: 有一个为false结果为false
  如果都为true结果才为true
或 ||: 有一个为true结果为true
  如果两个都为false结果才为false
非! : 取反
   当!的个数是奇数个的时候,结果相反
   当!的个数是偶数个的时候,结果不变

& 和 && 的区别 以及 | 和 || 的区别
  & 表示按位与,无论什么情况都会同时计算运算符两边的表达式
   && 表示逻辑与或者短路与, 如果前面的表达式为false,那么无论后面结果如何,都不会去计算后面表达式的值，会出现短路现象
  但是&常用于位运算, 位运算的效率比普通运算要高很多

代码示例

public class OperatorDemo06 {
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		System.out.println(a>b & a<b); // false & true = false
		System.out.println(a<b & a>b); // true & false = false
		System.out.println(a>b & a>b); // false & false = false
		System.out.println(a<b & a<b); // true & true = true
		
		System.out.println(a>b | a<b); // false | true = true
		System.out.println(a<b | a>b); // true | false = true
		System.out.println(a>b | a>b); // false | false = false
		System.out.println(a<b | a<b); // true | true = true
		
		System.out.println(a>b ^ a<b); // false ^ true = true
		System.out.println(a<b ^ a>b); // true ^ false = true
		System.out.println(a>b ^ a>b); // false ^ false = false
		System.out.println(a<b ^ a<b); // true ^ true = false
		
		System.out.println(!!!!!!!(a>b)); // !false = true*/
		
		System.out.println("====================");	
		
		System.out.println(a>b && a<b); // false & true = false
		System.out.println(a<b && a>b); // true & false = false
		System.out.println(a>b && a>b); // false & false = false
		System.out.println(a<b && a<b); // true & true = true
		
		System.out.println(a>b || a<b); // false | true = true
		System.out.println(a<b || a>b); // true | false = true
		System.out.println(a>b || a>b); // false | false = false
		System.out.println(a<b || a<b);*/ // true | true = true
		
		/*System.out.println("====================");	
		System.out.println(a>b && (10 / 0) == 0); // 不会报错，短路与 
		
		System.out.println(a // 不会报错，短路或
		System.out.println("====================");
		System.out.println(9 & 6); // 0   ①
		System.out.println(9 | 6); // 15   ②
		System.out.println(9 ^ 6); // 15   ③
	}
}
① ② ③的运算过程如下: 
1001 & 0110 = ？
			1 0 0 1
		&	0 1 1 0
		---------------
			0 0 0 0
			
		1001 | 0110 = ？
			1 0 0 1
		|	0 1 1 0
		---------------
			1 1 1 1
				
		1001 ^ 0110 = ？
			1 0 0 1
		^	0 1 1 0
		---------------
			1 1 1 1
		

条件运算符

条件运算符(三目运算符) ？:

格式: X ? Y : Z
  1.X表达式必须是boolean类型的表达式
  2.Y表达式和Z表达式的类型可以是任意类型，但是 Y和Z的类型必须保持一致
  3.整个表达式的值的类型要么是Y的类型或者是Z的类型
执行流程:
  首先计算X表达式的结果, 如果X的结果为true, 那么整个表达式的结果就是Y的值
   如果X表达式的结果为false,那么整个表达式的结果就是Z的值
注意: 关于三目运算符嵌套的问题,必须使用括号提高可读性

代码示例

public class OperatorDemo07 {
	public static void main(String[] args){
		
		// 计算两个数中较大的值
		int a = 300;
		int b = 200;
		
		int max = 0;
		max = a > b ? a: b;
		System.out.println("两个数中较大的值为: " + max);
		
		// 计算三个数中较大的值
		int x = 100;
		int y = 200;
		int z = 300;
		max = (x > y) ? (x > z ? x: z): (y > z ? y: z);
		System.out.println("三个数中较大的值为: " + max);
		
		// 小明考试成绩大于90分，奖励键盘一个，小于90奖励跪键盘一次
		String result = "";
		double score = 80;
		result = score > 90 ? "奖励键盘一个": "跪键盘去吧";
		System.out.println(result);
		
	}

表达式

表达式: 符合一定语法规则的运算符和操作数的式子

其中运算符和操作数指的是以下内容:
  运算符: 算数运算符,赋值运算符,关系运算符,逻辑运算符,位运算符(了解), 三目运算符
  操作数: 变量或者常量
  例如 a + b、a * 6、4 - 3、 i < 30 && i % 10 != 0

表达式的分类:
 按照复杂程度来分:
   简单表达式: 只有一个运算符的表达式 a + b a * 6 4 - 3
   复杂表达式: 两个或者两个以上的运算符组成的表达式 a > b && a < b
   如果复杂表达式就必须要知道运算符的优先级
按照运算符两边的操作数来分
  单目 双目 三目
   例如 +5 -6 ++a、3+a、x?y:z

表达式的值: 表示的是整个表达式的结果
表达式的值的类型: 表示的是整个表达式的结果值的数据类型

针对如下复杂表达式的运算我们必须学习运算符的优先级
(a - b) * c - 4
i < 30 && i % 10 != 0

观察如下表格:

优先级	描述	运算符
1	括号	()、[]
2	正负号	+、-
3	自增自减，非	++、–、!
4	乘除，取余	*、/、%
5	加减	+、-
6	移位运算	<<、>>、>>>
7	大小关系	>、>=、<、<=
8	相等关系	==、!=
9	按位与	&
10	按位异或	^
11	按位或	|
12	逻辑与	&&
13	逻辑或	||
14	条件运算	?:
15	赋值运算	=、+=、-=、*=、/=、%=
16	位赋值运算	&=、

通过观察表格我们大致可以总结以下常见的运算符的优先级特点:
   1.有括号先计算括号里面的
   2.单目运算符 > 双目运算符 > 三目运算符
   3.算数运算符(* / % > + -) > 关系运算符(> <… > == !=) > 逻辑运算符(&& > ||) > 条件运算符 > 赋值运算符
   4.如果运算符的优先级相同,从左至右即可
   5.赋值运算符从右往左运行
   技巧: 如果针对特别复杂的表达式,可以根据运算符的优先级规律,然后使用()改变优先级,提高程序的可读性

代码示例

public class OperatorDemo08 {
	public static void main(String[] args){
		int i = 10;
		// i < 30 && i % 10 != 0; 			
		// (i < 30) && ((i % 10) != 0)  true && false = false
		boolean result = i < 30 && i % 10 != 0;
		System.out.println(result);
		
		    // 7.int x = 4 , y = 2 , z = 3;求表达式y-=z++*--x的值是多少?表达式运行之后,x,y,z的值分别是多少?
		int x = 4;
		int y = 2;
		int z = 3;
		y -= z++*--x;
		/*
			y -= ((z++)*(--x)); ==> y = y - ((z++)*(--x))
			y = y - ((z++)*(--x))
			x 4 3
			y 2 -7
			z 3 4
			y = 2 - (3*3) = 2 - 9 = -7
		*/
		System.out.println("x=" + x + ",y=" + y + ",z=" + z);	
	}
}