ColorfulC ·Java 運算符
我們已經(jīng)學會了如何聲明變量和賦值變量。那么你可能想知道如何對它們進行操作。本小節(jié)我們學習的運算符就可以對它們進行運算。
運算符是一些特殊的符號，它們對一個，兩個或多個操作數(shù)執(zhí)行特定的運算，然后返回一個結果。這里的操作數(shù)指的就是運算符操作的實體。
Java提供了一組豐富的運算符來操作變量。 我們可以將所有Java運算符分為以下幾類：
- 算術運算符
- 關系運算符
- 位運算符
- 邏輯運算符
- 賦值運算符
- 其他運算符
本小節(jié)我們將按照以上分類介紹 Java 中的運算符，并在最后介紹運算符的優(yōu)先級。
1. 算術運算符
1.1 概述
Java 語言提供了執(zhí)行加減乘除四則運算的運算符。 算數(shù)運算符被用在數(shù)學表達式中，可以使用任意嵌套的小括號，其作用與數(shù)學中相同。下表列出了算術運算符：
（在例子中，初始化兩個整型變量a、b：int a = 2; int b = 4;）
| 運算符 | 描述 | 例子 |
|---|---|---|
+ |
加法運算符 （也用于字符串連接） | a + b 等于 6 |
- |
減法運算符 | a - b 等于 -2 |
* |
乘法運算符 | a * b 等于 8 |
/ |
除法運算符 | b / a 等于 2 |
% |
取余運算符 | b % a 等于 0 |
++ |
自增運算符 | a ++ 等于 3 |
-- |
自減運算符 | b – 等于 3 |
1.2 實例
以下是算數(shù)運算符的實例程序。
加法運算符使用實例：
public class ArithmeticOperators1 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1,num2 分別賦值為 2, 3
int num1 = 2, num2 = 3;
// 使用加法運算符，對num1和num2執(zhí)行相加操作，并將返回結果賦值給result
int result = num1 + num2;
System.out.println( num1 + " + " + num2 + " = " + result);
}
}
運行結果：
2 + 3 = 5
減法運算符使用實例：
public class ArithmeticOperators2 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1, num2 分別賦值為 5, 3
int num1 = 5, num2 = 3;
// 使用減法運算符，讓 num1 加上 num2，并將返回結果賦值給result
int result = num1 + num2;
System.out.println( num1 + " + " + num2 + " = " + result);
// 計算 num2 - num1 的結果
int result1 = num2 - num1;
System.out.println( num2 + " - " + num1 + " = " + result1);
}
}
運行結果：
5 + 3 = 8
3 - 5 = -2
乘法運算符使用實例：
public class ArithmeticOperators3 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1, num2 分別賦值為 2, 5
int num1 = 2, num2 = 5;
// 使用乘法運算符，讓 num1 與 num2 相乘，并將返回結果賦值給result
int result = num1 * num2;
System.out.println( num1 + " * " + num2 + " = " + result);
}
}
運行結果：
2 x 5 = 10
除法運算符使用實例：
public class ArithmeticOperators4 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1, num2 分別賦值為 10, 2
int num1 = 10, num2 = 2;
// 使用除法運算符，讓 num1 除以 num2，并將返回結果賦值給result
int result = num1 / num2;
System.out.println( num1 + " / " + num2 + " = " + result);
}
}
運行結果：
10 / 2 = 5
取余運算符使用實例：
public class ArithmeticOperators5 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1, num2 分別賦值為 5, 2
int num1 = 5, num2 = 2;
// 使用取余運算符，讓 num1 對 num2 取余，并將返回結果賦值給result
int result = num1 % num2;
System.out.println( num1 + " % " + num2 + " = " + result);
}
}
編譯執(zhí)行代碼，屏幕上將會打?。?/p>
5 % 2 = 1
自增、自減運算符使用實例：
public class ArithmeticOperators6 {
public static void main(String[] args) {
// 聲明兩個整型變量 num1, num2 分別賦值為 5, 2
int num1 = 5, num2 = 2;
// 打印 num1 和 num2
System.out.println("num1=" + num1);
System.out.println("num2=" + num2);
num1 ++;
num2 --;
System.out.println("num1自增后：" + num1);
System.out.println("num2自減后：" + num2);
}
}
運行結果：
num1=5
num2=2
num1自增后：6
num2自減后：1
另外，整型之間的除法運算是整除，這也就意味著2 / 4的結果為0，如果我們想像數(shù)學一樣得到一個小數(shù)，可以使用浮點類型的操作數(shù)。例如：
public class OperatorDemo1 {
public static void main(String[] args) {
// 分組初始化兩個整型變量i1、i2，值分別為2、4
int i1 = 2, i2 = 4;
// 使i1除以i2，并將返回結果賦值給i3
int i3 = i1 / i2;
System.out.println("整型2除以整型4的結果為：" + i3);
// 分組初始化兩個浮點型變量f1、f2，值分別為2、4
float f1 = 2f, f2 = 4f;
// 使f1除以f2，并將返回結果賦值給f3
float f3 = f1 / f2;
System.out.println("浮點型2除以浮點型4的結果為：" + f3);
}
}
運行結果：
整型2除以整型4的結果為：0
浮點型2除以浮點型4的結果為：0.5
要特別注意，在 Java 語言中，算數(shù)運算符不能作用于不同類型的操作數(shù)。我們來看一個反例：
public class OperatorDemo1 {
public static void main(String[] args) {
// 初始化布爾類型的變量b，值為true
boolean b = true;
// 初始化整型變量i，值為20
int i = 20;
// 使用加法運算符，讓i與b相加
int result = i + b;
}
}
編譯代碼，將會報錯：
javac OperatorDemo1.java
OperatorDemo1.java:7: 錯誤: 二元運算符 '+' 的操作數(shù)類型錯誤
int result = i + b;
^
第一個類型: int
第二個類型: boolean
1 個錯誤
編譯器給出明確提示：加法運算符的操作數(shù)類型錯誤。這是因為 Java 是強類型的語言，不同類型的操作數(shù)的算數(shù)運算是違規(guī)的，這個原理同樣適用于其他算數(shù)運算符，此處不再一一列舉。
還有一點，自增自減運算符是有前后之分的，++i表示先加1再引用i，i++表示先引用i再加1。將在下一小節(jié)舉例介紹。
2. 關系運算符
2.1 概述
關系運算符又稱為比較運算符，比較的結果是一個布爾類型的值（true或false）。
Java 語言有幾個可用于比較變量的運算符，如下表所示：
（在例子中，初始化兩個整型變量a、b：int a = 2; int b = 4;）
| 運算符 | 描述 | 例子 |
|---|---|---|
== |
檢查如果兩個操作數(shù)的值是否相等，如果相等則條件為真。 | (a == b) 為假 |
!= |
檢查如果兩個操作數(shù)的值是否相等，如果值不相等則條件為真。 | (a != b) 為真 |
> |
檢查左操作數(shù)的值是否大于右操作數(shù)的值，如果是那么條件為真。 | (a > b) 為假 |
< |
檢查左操作數(shù)的值是否小于右操作數(shù)的值，如果是那么條件為真。 | (a < b)為真 |
>= |
檢查左操作數(shù)的值是否大于或等于右操作數(shù)的值，如果是那么條件為真。 | (a >= b)為假 |
<= |
檢查左操作數(shù)的值是否小于或等于右操作數(shù)的值，如果是那么條件為真。 | (a <= b)為真 |
Tips：在比較兩個操作數(shù)是否相等時，必須使用“
==”而不是“=”。
3.2 實例
下面是一個比較運算符的實例程序：
public class OperateDemo2 {
public static void main(String[] args) {
// 初始化一個雙精度浮點型變量d1，值為10
double d1 = 10;
// 初始化一個整型變量i1，值也為10
int i1 = 10;
System.out.println("id == i1的結果為：" + (d1 == i1));
System.out.println("id != i1的結果為：" + (d1 != i1));
System.out.println("id > i1的結果為：" + (d1 > i1));
System.out.println("id < i1的結果為：" + (d1 < i1));
System.out.println("id >= i1的結果為：" + (d1 >= i1));
System.out.println("id <= i1的結果為：" + (d1 <= i1));
}
}
運行結果：
id == i1的結果為：true
id != i1的結果為：false
id > i1的結果為：false
id < i1的結果為：false
id >= i1的結果為：true
id <= i1的結果為：true
Tips：
>、<、>=、<=這幾個運算符左右兩邊的操作數(shù)必須是byte，short，int，long，double，float，char這幾種數(shù)據(jù)類型；而==和!=運算符的操作數(shù)既可以是基本數(shù)據(jù)類型，又可以是引用數(shù)據(jù)類型。
3. 位運算符
Java 語言還提供了對整數(shù)類型執(zhí)行按位和移位操作的運算符，稱作位運算符。
它在實際的編碼中并不常用，這部分內容了解即可。
假設a = 60，b = 13;它們的二進制格式表示將如下：
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~a = 1100 0011
下表列出了位運算符的基本運算，假設整數(shù)變量 a 的值為 60 和變量 b 的值為 13：
| 運算符 | 描述 | 例子 |
|---|---|---|
| ＆（按位與） | 如果相對應位都是1，則結果為1，否則為0 | （a＆b），得到12，即0000 1100 |
| |（按位或） | 如果相對應位都是 0，則結果為 0，否則為 1 | （a | b）得到61，即 0011 1101 |
| ^（按位異或） | 如果相對應位值相同，則結果為0，否則為1 | （a ^ b）得到49，即 0011 0001 |
| ?（按位取反） | 按位取反運算符翻轉操作數(shù)的每一位，即0變成1，1變成0。 | （?a）得到-61，即1100 0011 |
| << （左位移） | 按位左移運算符。左操作數(shù)按位左移右操作數(shù)指定的位數(shù)。 | a << 2得到240，即 1111 0000 |
| >> （右位移） | 按位右移運算符。左操作數(shù)按位右移右操作數(shù)指定的位數(shù)。 | a >> 2得到15即 1111 |
| >>> （零填充右移） | 按位右移補零操作符。左操作數(shù)的值按右操作數(shù)指定的位數(shù)右移，移動得到的空位以零填充。 | a>>>2得到15即0000 1111 |
4. 邏輯運算符
4.1 概述
邏輯運算符可以在表達式中生成組合條件，例如在執(zhí)行特定語句塊之前必須滿足的兩個或多個條件。使用邏輯運算符，可以描述這些組合條件。邏輯運算的返回結果只能為真或假。
Java 語言中的邏輯運算符，如下表所示：
（在例子中，初始化兩個整型變量a、b：int a = 0; int b = 1;）
| 運算符 | 描述 | 例子 |
|---|---|---|
| &&（邏輯與） | 當且僅當兩個操作數(shù)都為真，條件才為真。 | (a && b)為假 |
| || （邏輯或） | 如果任何兩個操作數(shù)任何一個為真，條件為真。 | (a || b)為真 |
| ?。ㄟ壿嫹牵?/td> | 用來反轉操作數(shù)的邏輯狀態(tài)。如果條件為真，則邏輯非運算符將得到假。 | !(a && b)為假 |
4.2 短路運算
&&和||運算符存在短路行為。短路的意思是：只有在需要的時候才會判斷第二個操作數(shù)的真假。例如：
class LogicOperators {
public static void main(String[] args){
int a = 1, b = 2;
if((a == 2) && (b == 2)) {
System.out.println("a和b都等于2");
}
if((a == 1) || (b == 1)) {
System.out.println("a等于1或b等于1");
}
}
}
運行結果：
a等于1或b等于1
程序解析：有兩個整型變量a和b，值分別為1和2。第一個if語句的條件為邏輯與運算，其第一個操作數(shù)a == 2為假，所以無論第二個操作數(shù)是真是假，都不去判斷，條件直接被判定為假；第二個if語句的條件為邏輯或運算， 其第一個操作數(shù)a == 1為真，所以無論第二個操作數(shù)是真是假，都不會去判斷，條件直接被判定為真。這就是所謂的短路。
5. 賦值運算符
5.1 概述
賦值運算符是為指定變量分配值的符號。下標列出了常用 Java 中常用的賦值運算符：
| 運算符 | 描述 | 例子 |
|---|---|---|
| = | 簡單的賦值運算符。將值從右側操作數(shù)分配給左側操作數(shù)。 | c = a + b將a + b的值賦給c |
| += | 加和賦值運算符。它將右操作數(shù)添加到左操作數(shù)，并將結果分配給左操作數(shù)。 | c + = a等于c = c + a |
| -= | 減和賦值運算符。它從左側操作數(shù)中減去右側操作數(shù)，并將結果分配給左側操作數(shù)。 | c -= a等效于c = c – a |
| *= | 乘和賦值運算符。它將右操作數(shù)與左操作數(shù)相乘，并將結果分配給左操作數(shù)。 | c *= a等效于c = c * a |
| / = | 除和賦值運算符。它將左操作數(shù)除以右操作數(shù)，并將結果分配給左操作數(shù)。 | c /= a等于c = c / a |
5.2 實例
我們來看一個賦值運算符的實例：
public class OperateDemo5 {
public static void main(String[] args) {
// 分組初始化三個變量 num1、num2、result，值分別為 20、10、0
int num1 = 20, num2 = 10, result = 0;
System.out.println("初始值：");
System.out.print("num1=" + num1 + '\t');
System.out.print("num2=" + num2 + '\t');
System.out.print("result=" + result + "\t\n");
System.out.println("開始賦值運算：");
result += num1;
System.out.println("result += num1 結果為：" + result);
result -= num2;
System.out.println("result -= num2 結果為：" + result);
result *= num1;
System.out.println("result *= num1 結果為：" + result);
result /= num2;
System.out.println("result /= num2 結果為：" + result);
result %= 15;
System.out.println("result %= 15 結果為：" + result);
}
}
運行結果：
初始值：
num1=20 num2=10 result=0
開始賦值運算：
result += num1 結果為：20
result -= num2 結果為：10
result *= num1 結果為：200
result /= num2 結果為：20
result %= 15 結果為：5
6. 其他運算符
6.1 條件運算符（? :）
條件運算符也稱為三元運算符。我們會在條件語句小節(jié)中再次對其介紹。
該運算符由三個操作數(shù)組成，用于判斷布爾表達式。它的目的是確定應將哪個值分配給變量。條件運算符的語法為：
變量 = (布爾表達式) ? 值1 : 值2
如果布爾表達式為真，就將值1分配變量，否則將值2分配給變量。
下面是一個實例程序：
public class ConditionalOperators {
public static void main(String[] args) {
int age = 15;
System.out.println(age >= 18 ? "在中國你已經(jīng)成年" : "在中國你還未成年");
}
}
由于age變量值為15，小于18，age >= 18返回結果為假，因此編譯執(zhí)行后，屏幕將打?。?/p>
在中國你還未成年
6.2 instanceof 運算符
Tips：了解 instanceof 運算符需要一些面向對象的前置知識。目前你可以選擇性學習。
instanceof運算符將對象與指定類型進行比較，檢查對象是否是一個特定類型（類類型或接口類型）。
instanceof 運算符的語法為：
( Object reference variable ) instanceof (class/interface type)
如果instanceof左側的變量所指向的對象，是instanceof右側類或接口的一個對象，結果為真，否則結果為假。
public class InstanceOfOperators1 {
public static void main(String[] args) {
String name = "imooc";
boolean b = name instanceof String;
System.out.println("結果為：" + b);
}
}
由于字符串變量name是String類型，所以執(zhí)行代碼，屏幕會打印：
結果為：true
注意，instanceof運算符不能用于操作基本數(shù)據(jù)類型，如果將字符串類型name變量改為一個char類型的變量，編譯代碼將會報錯:
InstanceOfOperators1.java:4: 錯誤: 意外的類型
boolean b = name instanceof String;
^
需要: 引用
找到: char
1 個錯誤
7. 運算符的優(yōu)先級
當多種運算符在一同使用的時候，會有一個執(zhí)行先后順序的問題。
下表中的運算符按優(yōu)先順序排序。運算符越靠近表格頂部，其優(yōu)先級越高。具有較高優(yōu)先級的運算符將在具有相對較低優(yōu)先級的運算符之前計算。同一行上的運算符具有相同的優(yōu)先級。
| 類別 | 操作符 | 關聯(lián)性 |
|---|---|---|
| 后綴 | () [] . (點操作符) | 左到右 |
| 一元 | + + - ！? | 從右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 關系 | >> = << = | 左到右 |
| 相等 | == != | 左到右 |
| 按位與 | ＆ | 左到右 |
| 按位異或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 邏輯與 | && | 左到右 |
| 邏輯或 | | | | 左到右 |
| 條件 | ？： | 從右到左 |
| 賦值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 從右到左 |
| 逗號 | ， | 左到右 |
當相同優(yōu)先級的運算符出現(xiàn)在同一表達式中時，如何控制它們計算的先后呢。我們來看一個實例：
public class OperateorsPriority {
public static void main(String[] args) {
int a = 2;
int b = 4;
int c = 6;
int result = a + b - c + a;
System.out.println("result = " + result);
}
}
在計算result的語句的右側，+ 、-兩個運算符優(yōu)先級相同，如果我們不加以控制，將按照從左到右順序計算，打印結果為result = 2；但是如果我們想先計算a + b和c + a的值，再計算兩者之差，我們可以使用括號()將其順序進行控制：(a + b) - (c + a)，再執(zhí)行代碼將打印我們想要的結果：result = -2。
8. 小結
本小節(jié)我們按照分類介紹了Java的運算符，并且在最后給出了運算符的優(yōu)先級表格。本節(jié)內容可能有些繁雜，但細節(jié)不必全部記住，你可以在需要的時候回過頭來查查表格。當然，最好的方式還是多寫多練，對照實例和表格自己敲敲代碼，用心分析代碼執(zhí)行的流程，是增強記憶最好的方式。
2025 imooc.com All Rights Reserved |