運算符
1. 算術運算符
算術運算符用于執行基本的數學運算，像加、減、乘、除等。
| 運算符 | 描述 | 示例 |
|---|---|---|
| + | 加法 | int a = 5 + 3; // a 的值為 8 |
| - | 減法 | int b = 5 - 3; // b 的值為 2 |
| * | 乘法 | int c = 5 * 3; // c 的值為 15 |
| / | 除法 | int d = 6 / 3; // d 的值為 2 |
| % | 取模（取余） | int e = 7 % 3; // e 的值為 1 |
| ++ | 自增 | int f = 5; f++; // f 的值為 6 |
| -- | 自減 | int g = 5; g--; // g 的值為 4 |
2. 賦值運算符
賦值運算符用于給變量賦值。
| 運算符 | 描述 | 示例 |
|---|---|---|
| = | 簡單賦值 | int a = 5; // a 的值為 5 |
| += | 加后賦值 | int b = 5; b += 3; // b 的值為 8 |
| -= | 減后賦值 | int c = 5; c -= 3; // c 的值為 2 |
| *= | 乘后賦值 | int d = 5; d *= 3; // d 的值為 15 |
| /= | 除后賦值 | int e = 6; e /= 3; // e 的值為 2 |
| %= | 取模后賦值 | int f = 7; f %= 3; // f 的值為 1 |
3. 比較運算符
比較運算符用于比較兩個值，返回布爾類型（true?或?false）。
| 運算符 | 描述 | 示例 |
|---|---|---|
| == | 等于 | int a = 5; int b = 5; boolean c = (a == b); // c 的值為 true |
| != | 不等于 | int d = 5; int e = 3; boolean f = (d != e); // f 的值為 true |
| > | 大于 | int g = 5; int h = 3; boolean i = (g > h); // i 的值為 true |
| < | 小于 | int j = 5; int k = 7; boolean l = (j < k); // l 的值為 true |
| >= | 大于等于 | int m = 5; int n = 5; boolean o = (m >= n); // o 的值為 true |
| <= | 小于等于 | int p = 5; int q = 7; boolean r = (p <= q); // r 的值為 true |
4. 邏輯運算符
邏輯運算符用于組合布爾表達式。
| 運算符 | 描述 | 示例 |
|---|---|---|
| && | 邏輯與 | boolean a = true; boolean b = false; boolean c = (a && b); // c 的值為 false |
| || | 邏輯或 | boolean d = true; boolean e = false; boolean f = (d||e); //f 的值為 true` |
| ! | 邏輯非 | boolean g = true; boolean h = !g; // h 的值為 false |
5. 位運算符
位運算符用于對二進制位進行操作。
| 運算符 | 描述 | 示例 |
|---|---|---|
| & | 按位與 | int a = 5; int b = 3; int c = a & b; // c 的值為 1 |
| | | 按位或 | int d = 5; int e = 3; int f = d | e; // f 的值為 7 |
| ^ | 按位異或 | int g = 5; int h = 3; int i = g ^ h; // i 的值為 6 |
| ~ | 按位取反 | int j = 5; int k = ~j; // k 的值為 -6 |
| << | 左移 | int l = 5; int m = l << 1; // m 的值為 10 |
| >> | 右移 | int n = 5; int o = n >> 1; // o 的值為 2 |
| >>> | 無符號右移 | int p = -5; int q = p >>> 1; // q 的值為一個很大的正數 |
6. 三元運算符
三元運算符是一種簡潔的條件判斷語句。
條件表達式 ? 表達式1 : 表達式2;
int a = 5;
int b = 3;
int max = (a > b) ? a : b; // max 的值為 5
運算符優先級
運算符優先級決定了表達式中運算符的計算順序。優先級高的運算符先計算，相同優先級的運算符按照從左到右的順序計算。以下是 Java 運算符的優先級，從高到低排列：
- 后綴運算符：
() [] . - 一元運算符：
++ -- + - ! ~ - 乘除模運算符：
* / % - 加減運算符：
+ - - 移位運算符：
<< >> >>> - 關系運算符：
< <= > >= instanceof - 相等運算符：
== != - 按位與運算符：
& - 按位異或運算符：
^ - 按位或運算符：
| - 邏輯與運算符：
&& - 邏輯或運算符：
|| - 三元運算符：
? : - 賦值運算符：
= += -= *= /= %= &= ^= |= <<= >>= >>>=
在編寫表達式時，可以使用括號?()?來明確指定計算順序，提高代碼的可讀性。例如：
int result = (2 + 3) * 4; // 先計算括號內的加法，再計算乘法
+?運算符除了用于數值的加法運算外，還能用于字符串的連接操作
字符串連接基本規則
當?+?運算符的操作數中有一個是字符串類型時，Java 會將其他操作數轉換為字符串，然后進行連接操作。具體規則如下：
1. 字符串與基本數據類型連接
當字符串與基本數據類型（如?int、double、boolean?等）使用?+?運算符時，基本數據類型會自動轉換為字符串，然后與另一個字符串進行連接。
public class StringConcatenation {public static void main(String[] args) {// 字符串與 int 類型連接int num = 10;String str1 = "The number is: " + num;System.out.println(str1);// 字符串與 double 類型連接double d = 3.14;String str2 = "The value of pi is approximately: " + d;System.out.println(str2);// 字符串與 boolean 類型連接boolean isTrue = true;String str3 = "The condition is: " + isTrue;System.out.println(str3);}
}
在上述代碼中，num、d?和?isTrue?分別是?int、double?和?boolean?類型，當它們與字符串使用?+?運算符時，會自動轉換為字符串進行連接。
多個字符串與其他類型混合連接
+?運算符是從左到右依次進行計算的，當多個字符串和其他類型混合使用?+?運算符時，會按照順序依次進行連接。
public class MultipleStringConcatenation {public static void main(String[] args) {int a = 5;int b = 3;String result = "The sum of " + a + " and " + b + " is: " + (a + b);System.out.println(result);}
}
在上述代碼中，首先將?"The sum of "?與?a?轉換后的字符串連接，然后依次連接后續的字符串和變量。需要注意的是，(a + b)?用括號括起來是為了先進行數值加法運算，再將結果轉換為字符串進行連接。如果沒有括號，a?會先與前面的字符串連接，而不是先進行加法運算。
字符串連接中的類型轉換順序
當表達式中包含多個?+?運算符時，會按照從左到右的順序進行計算。一旦遇到字符串類型的操作數，后續的操作數都會被轉換為字符串進行連接。
public class ConversionOrder {public static void main(String[] args) {int x = 1;int y = 2;String s = "Result: ";System.out.println(s + x + y); // 先將 s 與 x 轉換后的字符串連接，再與 y 轉換后的字符串連接System.out.println(x + y + s); // 先進行 x + y 的數值加法運算，再將結果與 s 連接}
}
在上述代碼中，第一個?println?語句先將?s?與?x?轉換后的字符串連接，再與?y?轉換后的字符串連接，結果為?"Result: 12"；第二個?println?語句先進行?x + y?的數值加法運算，得到?3，再將?3?轉換為字符串與?s?連接，結果為?"3Result: "。
綜上所述，+?運算符在 Java 中用于字符串連接時，會根據操作數的類型自動進行類型轉換，按照從左到右的順序依次進行連接操作。在編寫代碼時，需要注意運算符的優先級和類型轉換順序，以確保得到預期的結果。
自動類型轉換
自動類型轉換，也稱為隱式類型轉換，是指在某些情況下，Java 編譯器會自動將一種數據類型轉換為另一種數據類型，而無需程序員進行額外的操作。自動類型轉換需要滿足以下兩個條件：
- 目標類型的范圍大于源類型的范圍：即目標類型能夠容納源類型的所有可能值。
- 數據類型兼容：兩種數據類型必須是兼容的，例如數值類型之間可以進行自動類型轉換。
以下是 常見的自動類型轉換示例：
public class AutomaticTypeConversion {public static void main(String[] args) {// 1. 從 byte 到 shortbyte byteValue = 10;short shortValue = byteValue;System.out.println("byte 轉換為 short: " + shortValue);// 2. 從 short 到 intshort anotherShortValue = 20;int intValue = anotherShortValue;System.out.println("short 轉換為 int: " + intValue);// 3. 從 int 到 longint anotherIntValue = 30;long longValue = anotherIntValue;System.out.println("int 轉換為 long: " + longValue);// 4. 從 int 到 floatint yetAnotherIntValue = 40;float floatValue = yetAnotherIntValue;System.out.println("int 轉換為 float: " + floatValue);// 5. 從 long 到 doublelong anotherLongValue = 50L;double doubleValue = anotherLongValue;System.out.println("long 轉換為 double: " + doubleValue);}
}
在上述代碼中，分別展示了從?byte?到?short、short?到?int、int?到?long、int?到?float?以及?long?到?double?的自動類型轉換。由于目標類型的范圍大于源類型的范圍，編譯器會自動進行轉換。
強制類型轉換
強制類型轉換，也稱為顯式類型轉換，是指當需要將一個范圍大的數據類型轉換為范圍小的數據類型時，程序員需要手動進行類型轉換。強制類型轉換可能會導致數據丟失，因為目標類型可能無法容納源類型的所有可能值。
目標類型 變量名 = (目標類型) 源類型變量;
public class ExplicitTypeConversion {public static void main(String[] args) {// 1. 從 double 到 intdouble doubleValue = 3.14;int intValue = (int) doubleValue;System.out.println("double 轉換為 int: " + intValue);// 2. 從 int 到 byteint intValue2 = 130;byte byteValue = (byte) intValue2;System.out.println("int 轉換為 byte: " + byteValue);// 3. 從 long 到 shortlong longValue = 32768L;short shortValue = (short) longValue;System.out.println("long 轉換為 short: " + shortValue);}
}
在上述代碼中，分別展示了從?double?到?int、int?到?byte?以及?long?到?short?的強制類型轉換。需要注意的是，強制類型轉換可能會導致數據丟失，例如?double?類型的小數部分會被截斷，int?或?long?類型的值可能會超出目標類型的范圍而導致溢出。
綜上所述，自動類型轉換是編譯器自動完成的，而強制類型轉換需要程序員手動進行。在進行強制類型轉換時，需要謹慎處理，避免數據丟失。
小于?int?類型的數據類型（如?byte、short?和?char）在進行運算時，通常都會自動轉換為?int?類型。
原因
- 保證運算精度：
byte、short?和?char?的取值范圍相對較小，在運算過程中結果可能會超出它們的表示范圍，轉換為?int?類型可以避免溢出問題，確保運算結果的準確性。 - 簡化指令集：Java 虛擬機（JVM）的指令集是為處理?
int?類型設計的。將小于?int?的數據類型轉換為?int?類型，可以統一處理整數運算，簡化 JVM 的指令集和運算規則，提高運算效率。
示例代碼
public class SmallerThanIntConversion {public static void main(String[] args) {// byte 類型運算byte byte1 = 10;byte byte2 = 20;// byte1 和 byte2 會自動轉換為 int 類型進行運算int byteResult = byte1 + byte2;System.out.println("byte 運算結果: " + byteResult);// short 類型運算short short1 = 30;short short2 = 40;// short1 和 short2 會自動轉換為 int 類型進行運算int shortResult = short1 + short2;System.out.println("short 運算結果: " + shortResult);// char 類型運算char char1 = 'A';char char2 = 'B';// char1 和 char2 會自動轉換為 int 類型進行運算int charResult = char1 + char2;System.out.println("char 運算結果: " + charResult);}
}
代碼解釋
byte?類型運算：byte1?和?byte2?是?byte?類型，但在執行?byte1 + byte2?運算時，它們會自動轉換為?int?類型，最終結果也是?int?類型。short?類型運算：short1?和?short2?是?short?類型，在運算時同樣會自動轉換為?int?類型，結果為?int?類型。char?類型運算：char?類型在 Java 中本質上是無符號的 16 位整數。char1?和?char2?在運算時會自動轉換為?int?類型，結果也是?int?類型。
如果要將運算結果賦值給小于?int?類型的變量，需要進行強制類型轉換，但要注意可能會出現數據溢出的問題。
