Java中的運算子

1.算術運算子

基本四則運算子+ - * / %

規則比較簡單，值得注意：

1. int型別/ int型別結果還是 int，需要使用 double 來計算，如圖
   
   運行結果如下：
   

2. 0 不能作為除數
   當0做除數時，會發生運行時例外（也稱非受查例外），
   
   運行結果如下
   

3. % 表示取余
   不僅僅可以對 int 求模，也能對 double 來求模，
   
   運行結果如下
   

增量賦值運算子 += -= *= /= %=

運行結果如下

其他增量賦值運算子相類似，

自增/自減運算子 ++ –

需要注意的是前置（后置）自增/自減
前置自增/自減，如下

運行結果如下

后置自增/自減，如下

運行結果如下

我們不難發現，前置自增/自減，先進行賦值，后再進行運算；
而后置自增/自減，先進行運算，后再賦值，
與C語言不同的是如下情況

它的運行結果如下

這一點是需要我們注意的，
小結：

1. 如果不取自增運算的運算式的回傳值，則前置自增和后置自增沒有區別，
2. 如果取運算式的回傳值，則前置自增的回傳值是自增之后的值，后置自增的回傳值是自增之前的值，

2.關系運算子

關系運算子主要有六個==、 !=、 < 、>、 <=、 >=，
注意，Java中，關系運算子的運算式回傳值都是boolean型別（ true 或者 false ），這是與C語言有所不同的，
例如：

運行結果如下

3.邏輯運算子

邏輯運算子主要有三個：&&、||、! ，
注意，邏輯運算子的運算元(運算元往往是關系運算子的結果)和回傳值都是 boolean型別

邏輯與 &&

規則：兩個運算元都為 true，結果為 true，否則結果為 false ，

邏輯或 ||

規則：兩個運算元都為 false，結果為 false，否則結果為 true，

邏輯非 !

規則：運算元為 true，結果為 false；運算元為 false，結果為 true(這是個單目運算子，只有一個運算元)，

運行結果如下

在這里，&& 和 || 遵守短路求值的規則，對于 &&，如果左側運算式值為 false，則運算式的整體的值一定是 false，無需計算右側運算式，同理，對于 ||，如果左側運算式值為 true，則運算式的整體的值一定是 true，無需計算右側運算式，

& 和 | (不推薦使用)

& 和 | 如果運算元為 boolean 的時候，也表示邏輯運算，但是和 && 以及 || 相比，它們不支持短路求值，

4.位運算子

Java 中對資料的操作的最小單位不是位元組，而是二進制位，位運算子主要有四個： & 、 | 、 ~ 、 ^

按位與 &

如果兩個二進制位都是 1，則結果為 1，否則結果為 0 ，

按位或 |

如果兩個二進制位都是 0，則結果為 0，否則結果為 1 ，

運行結果如下

其原因如下圖所示

按位取反 ~

如果該位為 0 則轉為 1，如果該位為 1 則轉為 0 ，

運行結果如下

分析如下圖

注意：

1. 0x 前綴的數字為 十六進制 數字，十六進制可以看成是二進制的簡化表示方式，一個十六進制數字對應 4 個二進制位，
2. 0xf 表示 10 進制的 15，也就是二進制的 1111，
3. printf 能夠格式化輸出內容，%x 表示按照十六進制輸出，
4. \n 表示換行符，

按位異或 ^

如果兩個數字的二進制位相同，則結果為 0，相異則結果為 1，

運行結果如下

其原因是，1的二進制表示為 0 1，2的二進制表示為 1 0，進行按位異或^運算，其結果二進制表示為 1 1 ，按照十六進制輸出為3，

5.移位運算(了解）

移位運算子有三個： << 、 >> 、 >>> ，它們都是按照二進制位來運算的，

左移 <<

最左側位不要了，最右側補 0 ，

右移 >>

最右側位不要了，最左側補符號位(正數補0，負數補1)，

無符號右移 >>>

最右側位不要了, 最左側補 0 ，

運行結果如下

原因如下

注意:

1. 左移 1 位，相當于原數字×2，左移 N 位，相當于原數字×2 的N次方，
2. 右移 1 位，相當于原數字÷2，右移 N 位，相當于原數字÷2 的N次方，
3. 由于計算機計算移位效率高于計算乘除，當某個代碼正好乘除 2 的N次方的時候可以用移位運算代替，
4. 移動負數位或者移位位數過大都沒有意義，

6.條件運算子

也叫三目運算子，只有一個：
運算式1 ? 運算式2 : 運算式3
當 運算式1 的值為 true 時，整個運算式的值為 運算式2 的值；當 運算式1 的值為 false 時，整個運算式的值為 運算式3 的值，
例如，兩個數中的較大的數，

運行結果如下

這樣，我們很輕松地就求取了兩數中的較大值，

7.運算子的優先級

運算子之間是有優先級的，具體的規則我在這里也不贅述了，也不必記憶，只要在可能存在歧義的代碼中加上括號即可，

8.小結

1. % 操作再 Java 中也能針對 double 來計算，
2. 需要區分清楚前置自增和后置自增之間的區別，
3. 由于 Java 是強型別語言，因此對于型別檢查較嚴格，因此像 && 之類的運算運算元必須是 boolean型別，
4. 要區分清楚 & 和 | 什么時候是表示按位運算，什么時候表示邏輯運算，
   整體來看，Java 的運算子的基本規則和 C 語言基本一致，

典型例題

一.交換兩個整數的值，在這里為大家提供三種方法，
方法一，使用中間變數，這也是最普遍的方法，

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int temp = a;//引入中間變數
        a = b;
        b = temp;
        System.out.println(a);
        System.out.println(b);
   }
}

方法二，使用加法原理，但是不足之處是資料可能會溢位

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a = a + b;//交換兩個數字，加法原理，不足是可能會溢位
        b = a - b;
        a = a - b;
        System.out.println(a);
        System.out.println(b);
   }
}

方法三，使用異或（^）位運算子

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a = a^b;//交換兩個數字，不使用中間變數,且不會溢位
        b = a^b;
        a = a^b;
        System.out.println(a);
        System.out.println(b);
   }
}

二.給定三個 int 變數，求其中的最大值和最小值，
上代碼

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30；
        int max = a > b ? a : b;// 求兩個整數的最大值
        max = max > c ? max :c;
        int min = a < b ? a : b;// 求兩個整數的最小值
        min = min < c ? min : c;
        System.out.println(max);
        System.out.println(min);
   }
}

就是如此之簡單，

Java中的關鍵字

用于定義訪問權限修飾符的關鍵字

private 、protected 、public ，

用于定義類，函式，變數修飾符的關鍵字

abstract 、final 、static 、synchronized ，

用于定義類與類之間關系的關鍵字

extends 、 implements ，

用于定義建立實體及參考實體，判斷實體的關鍵字

new 、this 、 super 、 instanceof ，

用于例外處理的關鍵字

try 、 catch 、 finally 、 throw 、 throws ，

用于包的關鍵字

package 、 import ，

其他修飾符關鍵字

native 、 strictfp 、transient 、 volatile 、 assert ，

隨著Java學習的不斷深入，會逐漸地總結到以上關鍵字，

程式邏輯控制

1.順序結構

順序結構比較簡單，就像我們之前寫過的代碼就是順序結構的，按照代碼書寫的順序一行一行執行，

System.out.println("111");
System.out.println("222");
System.out.println("333");

它的運行結果就為
111
222
333

2.分支結構

1.if 陳述句

基本語法形式1

if(布爾運算式){
    //條件滿足時執行代碼
}

基本語法形式2

if(布爾運算式){
    //條件滿足時執行代碼
}else{
    //條件不滿足時執行代碼
}

基本語法形式3 多分支的情況

if(布爾運算式){
    //條件滿足時執行代碼
}else if(布爾運算式){
    //條件滿足時執行代碼
}else{
    //條件都不滿足時執行代碼
}

注意，懸垂else問題
if / else 陳述句中可以不加大括號，但是也可以寫陳述句(只能寫一條陳述句). 此時 else 是和最接近的 if 匹配（也就是就近原則），但是實際開發中不建議這么寫，最好加上大括號，
三個常見編程題（多分支）
1.判斷一個整型數字是奇數還是偶數

public class TestDemo {
    public static void main(String[] args) {        
        int num = 10;//判斷一個數字是奇數還是偶數
        if (num % 2 == 0) {
            System.out.println("num 是偶數");
        } else {
            System.out.println("num 是奇數");
        }
   }
}

2.判定一個數字是正數還是負數

public class TestDemo {
    public static void main(String[] args) {        
        int num = 10;
        if (num > 0) {
            System.out.println("num 是正數");
        } else if (num < 0) {
            System.out.println("num 是負數");
        } else {
            System.out.println("num 是 0");
        }
   }
}

3.判斷一個年份是否為閏年，

public class TestDemo {
    public static void main(String[] args) {        
        int year = 2021;
        if (year % 100 == 0) {
            // 判定世紀閏年
            if (year % 400 == 0) {
                System.out.println("是閏年");
            } else {
                System.out.println("不是閏年");
            }
        } else {
            // 普通閏年
            if (year % 4 == 0) {
                System.out.println("是閏年");
            }else {
                System.out.println("不是閏年");
            }
        }
   }
}

由運行結果可知，2021年不是閏年，

2.switch 陳述句

基本語法

switch(整數|列舉|字符|字串){
     case 內容1 : {
         內容滿足時執行陳述句;
         [break;]
         }
     case 內容2 : {
         內容滿足時執行陳述句;
         [break;]
         }
     ...
     default:{
         內容都不滿足時執行陳述句;
         [break;]
         }
}

根據 switch 中值的不同，會執行對應的 case 陳述句，遇到 break 就會結束該 case 陳述句，如果 switch 中的值沒有匹配的 case，就會執行 default 中的陳述句，建議一個 switch 陳述句最好都要帶上 default 陳述句，

3.回圈結構

1.while 回圈

基本語法格式:

while(回圈條件){
    回圈陳述句;
} 

回圈條件為 true，則執行回圈陳述句；否則結束回圈，
注意事項

1. 和 if 類似, while 下面的陳述句可以不寫 { } ，但是不寫的時候只能支持一條陳述句，建議還是加上 { }，
2. 和 if 類似，while 后面的 { 建議和 while 寫在同一行，
3. 和 if 類似，while 后面不要多寫分號，否則會導致回圈不能正確執行，

例，計算1！+2！+3！+4！+5！

public class TestDemo {
    public static void main(String[] args) {        
        int num = 1;
        int sum = 0;
        // 外層回圈負責求階乘的和
        while (num <= 5) {
          int factorResult = 1;
          int tmp = 1;
          // 內層回圈負責完成求階乘的細節
          while (tmp <= num) {
             factorResult *= tmp;
             tmp++;
          }
          sum += factorResult;
          num++;
       }
       System.out.println("sum= " + sum);
   }
}

2.break

break 的功能是讓回圈提前結束，也就是跳出回圈，

3.continue

continue 的功能是跳過這次回圈，立即進入下次回圈，

4.for 回圈

基本語法

for(運算式1;運算式2;運算式3){
    回圈體;
} 

運算式1: 用于初始化回圈變數，
運算式2: 回圈條件，
運算式3: 更新回圈變數，
與 while 回圈相比，for 回圈將這三個部分合并在一起, 寫代碼時不容易遺漏，

5.do while 回圈

基本語法

do{
   回圈陳述句;
}while(回圈條件);

這個回圈，最大的不同就是先執行回圈陳述句，然后再判定回圈條件，

到這里，Java入門（二）基本結束了，下面為大家提供一個通過Java編程實作的小游戲，猜數字游戲，

import java.util.Random;
import java.util.Scanner;;
public class TestDemo {
    public static void main(String[] args) {
        Random random = new Random(); // 默認隨機種子是系統時間
        Scanner sc = new Scanner(System.in);
        int toGuess = random.nextInt(100);
        // System.out.println("toGuess: " + toGuess);
        while (true) {
            System.out.println("請輸入要輸入的數字: (1-100)");
            int num = sc.nextInt();
            if (num < toGuess) {
                System.out.println("小了");
            } else if (num > toGuess) {
                System.out.println("大了");
            } else {
                System.out.println("恭喜回答正確");
                break;
            }
        }
        sc.close();
    }
}

鐵汁們，我們下期見，