運算符號

　

作者：　許裕永

資料的運算，自然要利用運算符號。兩個資料用一個運算符號串聯起來，即為一個運算式，一句敍述句可以是多個運算式的串聯。例：ａ＝ｂ＋ｃ＋ｄ；這一句敍述 句包含了３個運算式；它會先把ｂ和ｃ做加的運算，再把運算後的值和ｄ做加的運算，再把運算後的值指派給ａ，所以它是二個算術運算式及一個指派運算式串聯的 敍述句。而運算的順序，除了後續部份有特別介紹的運算符號之外，不外乎先乘除後加減，由左向右，括號先算。
　不同資料型別的資料是無法運算的。所以，當運算式要運算不同資料型別的資料時，Ｊａｖａ會先依上一章所敍述之自動轉換的原則，將資料轉換為相同的資料型別再行運算，若有無法執行自動轉換的資料，則會產生編譯時期錯誤。



1. 算術運算符號

符號	意義	範例
＋	求和	ａ＋ｂ
－	求差；負值	ａ－ｂ，－ｂ
＊	求積	ａ＊ｂ
／	求商	ａ／ｂ
％	求餘數	ａ％ｂ
＋＋	增量（加１）	ａ＋＋，＋＋ａ
──	減量（減１）	ａ──，──ａ

１－１　四則運算：
用＋、－、＊、／來運算數值。特別要注意的是：整數運算式中若有ｂｙｔｅ或ｓｈｏｒｔ型別的變數時，此運算式運算後的型別為ｉｎｔ。原理很簡單：因為 ｂｙｔｅ或ｓｈｏｒｔ的最大值或最小值無論是與任何數值做運算，均可能會超過其最大值或最小值的範圍。總而言之：整數運算式的預設型別為ｉｎｔ。
例：
byte a=3;
byte b=8+8; //此句正確
byte c=a+8; //此句編譯錯誤
第三句敍述句的算術運算式中有ｂｙｔｅ型別的變數ａ，所以運算後的值為ｉｎｔ型別，無法指派給ｂｙｔｅ型別的變數ｃ。
另一個重點，是強制轉型的使用。例：“（ｉｎｔ）ａ＋ｂ；”與“（ｉｎｔ）（ａ＋ｂ）；”所轉換的對象是不一樣的。前一句是轉換ａ的值後再與ｂ做加的運算；後一句是先執行ａ＋ｂ的運算後再轉換。
例：
int a=5;
byte b=(byte)a+8; //編譯錯誤
byte c=(byte)(a+8); //正確
第二行敍述句中，ｉｎｔ型別變數ａ會先轉為ｂｙｔｅ型別，再與８做加的運算。但ｂｙｔｅ型別的變數做加的運算，其運算結果還是ｉｎｔ型別，所以無法指派給ｂｙｔｅ型別的變數ｂ。
１－２　＋：
若此運算符號的左值或右值中有字串資料（置於“”中之資料）時，則所有型別的資料均會自動轉型為字串資料（含布林值及參考資料型別），再進行字串串聯的運算。（參考資料型別會呼叫方法ｔｏＳｔｒｉｎｇ（），後續章節介紹）
例：
System.out.println(“1”+2+3);
此句字串“１”先和數值２運算，串聯為“１２”後再與數值３運算，結果為“１２３”
System.out.println(1+2+”3”);
此句數值１先和數值２運算為數值３後再與字串“３”運算，結果為“３３”




System.out.println(“1”+2+true);
此句字串“１”先和數值２運算，串聯為“１２”後再與ｔｒｕｅ運算，結果為“１２ｔｒｕｅ”
System.out.println(1+2+true);
此句數值１先和數值２運算為數值３後，再要與布林值ｔｒｕｅ運算時，因資料型別無法轉換（布林值只能轉換為字串，無法轉換為其他型態），產生編譯錯誤。
１－３　／：
此運算符號要注意：整數運算的結果還是整數，不會取小數點，更不會自動四捨五入。
例：
int a=8/3;
float b=8/3; //8/3運算結果2為int型別
//再自動轉型為float指派給b
System.out.println(a); //值為２
System.out.println(b); //值為2.0
１－４　％：
求餘數的運算。一般用來判斷除數與被除數之間是否為倍數關係。例：８％２之值為０，所以８是２的倍數；也可以用來控制整數數值的範圍，讓該數值介於某一特定範圍之中。例：任意整數％８之值必定介於０到７之間。
１－５　＋＋：
增量運算，就是變數自己執行加１的運算。一般用來做計數的動作。
例一：
int a=8;
a++; //此句運算後ａ之值為９
++a; //此句運算後ａ之值為１０
無論此符號置於變數前或變數後，均代表該變數自己執行加１的運算。
但若敍述句中還串聯其它運算符號時，增量運算符號置於變數前或變數後，將會改變該敍述句的運算結果。
例二：
int a=8;
int b=a++ +8; //++和＋之間必須有空格
此例稱之為：「運算後增量」。運算指的是ａ與ｂ做加的運算。增量指的是變數ａ自行加１的運算。此例中，增量運算符號置於變數ａ的後方，所以會先執行ａ與ｂ加的運算之後，再執行變數ａ增量的運算，故稱之為運算後增量。因為執行ａ＋ｂ時，ａ尚未增量，所以ｂ的值為１６。
例三：
int a=8;
int b=++a+8;
此例稱之為：「運算前增量」。此例中，增量運算符號置於變數ａ的前方，所以會先執行變數ａ增量的運算之後，再執行ａ與ｂ加的運算，故稱之為運算前增量。因為執行ａ＋ｂ時，ａ已經增量，所以ｂ的值為１７。
在這兩個範例中，我們必須注意：會因為增量符號的位置而改變的，並不是變數ａ的值（均為９）。而是指派運算符號（＝）的右側，整個運算式的運算結果。另一個值得注意的是：增量符號若置於變數前方，則其運算順序，優先於任何其他運算符號。
１－６　──：
減量運算，就是變數自己執行減１的運算。運算模式同增量運算，請自行練習。
2. 指派運算符號
指派運算符號的左值與右值不可以對換。在算術運算式中：ａ＋ｂ與ｂ＋ａ運算結果並無不同。但在指派運算式中：ａ＝ｂ與ｂ＝ａ便截然不同。指派運算符號指的 是：把右值指派到左值所代表的記憶體空間裏。左值的變數指的是該變數所代表的記憶體空間，右值的變數指的是：該變數所代表的記憶體空間裏所儲存的值。

符號	範例	同義敍述
＝	ａ＝ｂ
＋＝	ａ＋＝ｂ	ａ＝ａ＋ｂ
－＝	ａ－＝ｂ	ａ＝ａ－ｂ
＊＝	ａ＊＝ｂ	ａ＝ａ＊ｂ
／＝	ａ／＝ｂ	ａ＝ａ／ｂ
％＝	ａ％＝ｂ	ａ＝ａ％ｂ

上列表格中的同義敍述，表示兩種寫法的執行結果相同。但若深究Ｊａｖａ的運算模式，它們還是有差別的。
例：
byte a=3;
a=a+3; //編譯錯誤
a+=3; //正確
在此例中，ａ＝ａ＋３的指派運算符號（＝）的右值為ａ＋３，這是一個整數運算式，而整數運算式的預設型別為ｉｎｔ，自然無法指派給ｂｙｔｅ型別的變數ａ。但ａ＋＝３的指派運算符號（＋＝）的右值為整數值３，不是運算式，屬於直接指派，所以正確。




3. 條件運算符號
用來比較左值及右值之間，大於、小於或等於關係的符號。因為一般用於程式語言中判斷敍述的條件運算，所以稱之為條件運算符號，而運算式便稱之為條件運算式。但也可稱之為比較運算符號或關係運算符號。
條件運算式運算的結果便是布林值，只有兩種變化：ｔｒｕｅ／ｆａｌｓｅ。

符號	意義	範例
＝＝	等於	ａ＝＝ｂ
！＝	不等於	ａ！＝ｂ
＞	大於	ａ＞ｂ
＞＝	大於等於	ａ＞＝ｂ
＜	小於	ａ＜ｂ
＜＝	小於等於	ａ＜＝ｂ

特別要注意的是：指派運算符號＝，和條件運算符號＝＝的差別。
例：
boolean a=3>5; //ａ的值為ｆａｌｓｅ
boolean b=5<3; //ｂ的值為ｆａｌｓｅ
boolean c=a==b;
boolean d=a=b;
第三行敍述句，是運算ａ＝＝ｂ的值，再將值指派給ｃ，因為ａ和ｂ均為ｆａｌｓｅ，所以ｃ的值為ｔｒｕｅ。而第四行敍述句，是把ｂ的值指派給ａ，再指派給ｄ，所以ｄ，ａ，ｂ之值均為ｆａｌｓｅ。




4. 邏輯運算符號
算術運算符號可以串聯。例：ａ＋ｂ＋ｃ，代表先運算ａ＋ｂ再將運算結果執行＋ｃ的運算。但是條件運算符號若串聯，便會產生錯誤。例：ａ＜ｂ＜ｃ，因為ａ＜ｂ運算完的結果是布林值（ｔｒｕｅ／ｆａｓｌｅ），而布林值是沒有辦法和ｃ做＜的運算的。
若要做布林值與布林值的運算（條件運算式與條件運算式的運算），或說是條件運算式的串聯運算時，就要使用邏輯運算符號。

符號	意義	範例
＆	長程　ａｎｄ	ａ＜ｂ　＆　ｂ＜ｃ
＆＆	短程　ａｎｄ	ａ＜ｂ　＆＆　ｂ＜ｃ
｜	長程　ｏｒ	ａ＜ｂ　｜　ａ＜ｃ
｜｜	短程　ｏｒ	ａ＜ｂ　｜｜　ａ＜ｃ
！	ｎｏｔ	！（ａ＝＝ｂ）

４－１　＆，＆＆(and)：
ａｎｄ的運算，必須是運算符號的左值（左側的條件運算式）及右值（右側的條件運算式）均為ｔｒｕｅ時，其運算結果方為ｔｒｕｅ。若左值及右值中任意一個或兩個的值均為ｆａｌｓｅ時，其運算結果便為ｆａｌｓｅ。
長程（＆）及短程（＆＆）的差異在於：長程運算無論左值之運算結果為何，均會運算右值，而短程運算是在左值運算值為ｔｒｕｅ時，才會運算右值。這是因為當左值為ｆａｌｓｅ時，則此邏輯運算的結果必然為ｆａｌｓｅ。使用短程運算，可以節省不必要的運算。
例一：
int a=5,b=6;
boolean c=a++>=b;
boolean d=--a>=b;
此例中，ｃ的值為ｆａｌｓｅ：因為＋＋是運算後增量，所以先運算ａ＞＝ｂ的值為ｆａｌｓｅ，再運算ａ＋＋，ａ的值便為６。ｄ的值也是ｆａｓｌｅ：因為──是運算前減量，所以先運算──ａ，ａ的值便為５，再運算ａ＞＝ｂ的值為ｆａｌｓｅ。
例二：
int a=5,b=5,c=5;
boolean d=a++>=b++ && b>c++;
此例運算結果為：ａ＝６，ｂ＝６，ｃ＝６，ｄ＝ｔｒｕｅ。其運算順序為：ａ＞＝ｂ　－＞　ａ＋＋　－＞　ｂ＋＋　－＞　ｂ＞ｃ　－＞　ｃ＋＋。
例三：
int a=5,b=5,c=5;
boolean d=a++>b++ && b>c++;
此例運算結果為：ａ＝６，ｂ＝６，ｃ＝５，ｄ＝ｆａｌｓｅ。其運算順序為：ａ＞ｂ　－＞　ａ＋＋　－＞　ｂ＋＋。因為＆＆是短程運算，而左值（ａ＋＋＞ｂ＋＋）為ｆａｌｓｅ，所以右值（ｂ＞ｃ＋＋）不運算。
例四：
int a=5,b=5,c=5;
boolean d=a++>b++ & b>c++;
此例運算結果為：ａ＝６，ｂ＝６，ｃ＝６，ｄ＝ｆａｌｓｅ。其運算順序為：ａ＞ｂ　－＞　ａ＋＋　－＞　ｂ＋＋　－＞　ｂ＞ｃ　－＞　ｃ＋＋。因為＆是長程運算，雖然左值（ａ＋＋＞ｂ＋＋）為ｆａｌｓｅ，但右值（ｂ＞ｃ＋＋）仍會運算。
４－２　｜，｜｜(or)：
ｏｒ的運算，只要運算符號的左值或右值其中一個為ｔｒｕｅ時，其運算結果便為ｔｒｕｅ。只有左值及右值的值均為ｆａｌｓｅ時，其運算結果才為ｆａｌｓｅ。
長程（｜）及短程（｜｜）的差異在於：長程運算無論左值之運算結果為何，均會運算右值，而短程運算是只有在左值運算值為ｆａｌｓｅ時，才會運算右值。這是因為當左值為ｔｒｕｅ時，則此邏輯運算的結果必然為ｔｒｕｅ，使用短程運算，可以節省不必要的運算。
例一：
int a=5,b=5,c=5;
boolean d=a++>b++ || b>c++;
此例運算果為：ａ＝６，ｂ＝６，ｃ＝６，ｄ＝ｔｒｕｅ。其運算順序為：ａ＞ｂ　－＞　ａ＋＋　－＞　ｂ＋＋　－＞　ｂ＞ｃ　－＞　ｃ＋＋。因為左值（ａ＋＋＞ｂ＋＋）之值為ｆａｌｓｅ所以會運算右值（ｂ＞ｃ＋＋）。
例二：
int a=5,b=5,c=5;
boolean d=a++>=b++ || b>c++;
此例運算果為：ａ＝６，ｂ＝６，ｃ＝5，ｄ＝ｔｒｕｅ。其運算順序為：ａ＞ｂ　－＞　ａ＋＋　－＞　ｂ＋＋。因為｜｜是短程運算，而左值（ａ＋＋＞ｂ＋＋）之值為ｔｒｕｅ，所以右值（ｂ＞ｃ＋＋）不會運算。
例三：
int a=5,b=5,c=5;
boolean d=a++>=b++ | b>c++;
此例運算果為：ａ＝６，ｂ＝６，ｃ＝６，ｄ＝ｔｒｕｅ。其運算順序為：ａ＞ｂ　－＞　ａ＋＋　－＞　ｂ＋＋　－＞　ｂ＞ｃ　－＞　ｃ＋＋。因為｜是長程運算，雖然左值（ａ＋＋＞ｂ＋＋）之值為ｔｒｕｅ，但右值（ｂ＞ｃ＋＋）仍會運算。
４－３　ａｎｄ及ｏｒ的綜合使用：
若一個邏輯運算式中，串聯了ａｎｄ及ｏｒ的運算符號，則其運算順序為：長程優先於短程，ａｎｄ優先於ｏｒ。例：ａ＞ｂ　＆＆　ｂ＞ｃ　｜｜　ａ＞ｄ；此敍 句會先執行ａ＞ｂ　＆＆　ｂ＞ｃ再將運算結果和ａ＞ｄ做ｏｒ的運算。而因為都是短程運算符號，所以若ａ＞ｂ為ｆａｌｓｅ則ｂ＞ｃ不會運算，而會直接運算 ａ＞ｄ；但若ａ＞ｂ為ｔｒｕｅ且ｂ＞ｃ為ｔｒｕｅ，則ａ＞ｄ不會運算。
例一：
int a=5,b=5,c=5,d=5;
boolean e=a>b && b>c ||a++>d;
此例運算結果為：ａ＝６，ｂ＝５，ｃ＝５，ｄ＝５，ｅ＝ｆａｌｓｅ。因為｜｜的左值（ａ＞ｂ　＆＆　ｂ＞ｃ）為ｆａｌｓｅ，所以右值（ａ＋＋＞ｄ）會運算。
例二：
int a=5,b=5,c=5,d=5;
boolean e=a>=b && b>=c ||a++>d;
此例運算結果為：ａ＝５，ｂ＝５，ｃ＝５，ｄ＝５，ｅ＝ｔｒｕｅ。因為｜｜的左值（ａ＞ｂ　＆＆　ｂ＞ｃ）為ｔｒｕｅ，所以右值（ａ＋＋＞ｄ）不會運算。
４－４　！：
ｎｏｔ的運算是：反轉運算符號右值之布林值。ｔｒｕｅ轉為ｆａｌｓｅ；ｆａｌｓｅ轉為ｔｒｕｅ。使用此運算符號時，須注意右側括號的使用。例：！ａ＞ｂ 　＆＆　ｂ＞ｃ；及！（ａ＞ｂ　＆＆　ｂ＞ｃ）所反轉的對象是不一樣的。前一句是反轉ａ＞ｂ的值後，再與ｂ＞ｃ做ａｎｄ的運算。後一句是反轉（ａ＞ｂ 　＆＆　ｂ＞ｃ）運算後的值。
例：
boolean a=5>3;
boolean b=false;
boolean c=!a;
boolean d=!a && b;
boolean e=!(a&&b);
此例運算結果為：ａ＝ｔｒｕｅ，ｂ＝ｆａｓｌｅ，ｃ＝ｆａｌｓｅ，ｄ＝ｆａｓｌｅ，ｅ＝ｔｒｕｅ。其中ｄ的值是由！ａ（ｆａｌｓｅ）與ｂ（ｆａｌｓｅ）做 ａｎｄ的運算。而ｅ的值是運算！（ｔｒｕｅ　＆＆　ｆａｌｓｅ），括號中的值為ｆａｌｓｅ，再經過！的反轉運算，便得到ｔｒｕｅ的運算結果。




5. ｉｎｓｔａｎｃｅｏｆ
ｉｎｓｔａｎｃｅｏｆ用來比較左值與右值型別的關係，專用在參考變數及參考資料型別。一般變數及基本資料成員並不會用到。（讀者可先行略過，等學到物件多型時再回頭來看）。
語法：參考變數　instanceof 參考資料型別。
運算結果：ｔｒｕｅ、ｆａｌｓｅ或編譯錯誤。
ｔｒｕｅ：若參考變數所代表的物件，是參考資料型別的物件（物件多型）。
ｆａｌｓｅ：若參考變數所代表的物件，不是參考資料型別的物件（物件多型）。
編譯錯誤：若參考變數所代表的物件，和參考資料型別並非同一條繼承線（無父子關係），或沒有實作該界面。
例：
String s=new String(“Java”);
System.out.println(s instanceof String);//true
System.out.println(s instanceof Object);//true
Object o=new Object():
System.out.println(o instanceof String);//false
System.out.println(o instanceof Object);//true
Integer i=new Integer(8);
System.out.println(i instanceof Integer);//true
System.out.println(i instanceof Object);//true
//System.out.println(I instanceof String);本句註解取消將造成編譯錯誤