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<b || (10 / 0) == 0);*/ // 不會報錯，短路或
		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);	
	}
}