1， 運算子

1.1 算數運算子

  開發中使用的算數運算子：
   + - * / % （） = 
   % 取餘： 例如： 5 ÷ 2 = 2...1  ==> 5 % 2 = 1

// 算術運算子演示
class Demo1 {
public static void main(String[] args) {
	// 定義兩個 int 型別變數
	int num1 = 10;
	int num2 = 20;
	
	/*
	注意事項：
		1. 在程式碼執行過程中，變數儲存資料內容有可能會隨著程式碼執行發生改變。
		2. 變數儲存資料有且只能是在被賦值的情況下才可以改變，未賦值不變
	*/
	num1 = num1 + num2; // num1 = 30 num2 = 20
	num1 = num1 * num2; // num1 = 600 num2 = 20
	num1 = num1 - num2; // num1 = 580 num2 = 20;
	num1 = num1 / num2; // num1 = 29 num2 = 20;
	num1 = num1 % num2; // num1 = 9 num2 = 20;
	
	System.out.println(num1);
	System.out.println(num2);	
}
 

}

1.2 增強版運算子

  +=  -=  *=  %=  /=
  案例:
int num1 = 10;
int num2 = 20;

num1 = num1 + num2; ==> num1 += num2;

  優勢:
1. 減少變數書寫，避免錯誤！！！
2. 帶有一定的特殊功能，包含隱含型別轉換！！！

1.3 自增自減運算子

    【建議】
  1. 自增自減充滿了歧義性，開發中儘量減少自增自減運算子使用。
  2. 推薦使用 += 1 和 -= 1 替代自增自減運算子。
  3. 自增自減運算子操作單獨成行

    【語法要求】
  1. 自增自減運算子有且只可以操作【變數】
  2. 自增自減運算子在變數之前或者變數之後有不同的效果。

    【語法效果】
  1. 自增自減運算子在變數之後，首先取值變數儲存資料內容，參與當前行程式碼執行，再來執行自增自減操作
  2. 自增自減運算子在變數之前，首先執行自增自減操作，對變數資料進行修改，再取值變數儲存資料內容，參與當前行程式碼執行。
 

1.4 關係運算符

    格式： 
      > < >= <= == !=
    對外資料形式：
      boolean  true or fasle
      關係運算符兩邊的資料結果滿足關係運算符所需，結果為 true， 否則為 fasle
   // 關係運算符
class Demo3 {
public static void main(String[] args) {
	boolean ret = 5 > 3;
	System.out.println(ret); // true
	
	ret = 5 < 3;
	System.out.println(ret); // false 
	
	ret = 5 >= 5;
	System.out.println(ret); // true 
	
	ret = 5 <= 15;
	System.out.println(ret); // true 
	
	ret = 5 != 15;
	System.out.println(ret); // true 
	
	ret = 5 == 15;
	System.out.println(ret); // false 
    }
}
 

1.5 邏輯運算子

    && 與
        同真為真， 有假即假
    || 或
        有真【即】真，同假為假
    ! 非 取反
          真變假，假變真
// 邏輯運算子
class Demo4 {
public static void main(String[] args) {
	boolean ret = 10 > 5 && 5 > 1;
	System.out.println(ret); // true
	
	ret = 10 > 5 && 1 > 5;
	System.out.println(ret); // false
	
	ret = 10 > 5 || 1 > 5;
	System.out.println(ret); // true
	
	ret = 10 < 5 || 1 > 5;
	System.out.println(ret); // false
	
	ret = !(5 > 5);
	System.out.println(ret); // true
	
	ret = !(5 == 5);
	System.out.println(ret); // false
    }
  }

1.6 邏輯運算子短路原則

   後期可以利用邏輯運算子短路原則，進行條件排列，提高開發效率，提高執行效率
    int num = 10;
    boolean ret = 10 > 50 && ++num > 5;

    ret = false;
    num = 10;

    /*
    邏輯與 同真為真，有假【即】假
    邏輯與短路原則：
邏輯與表示式，出現 false 條件，整個表示式結果已明確為 false，計算機            為了提高效率，從 false 條件開始，之後的表示式不再執行。
  */

    int num = 10;
    boolean ret = 10 > 5 || ++num > 5;

    ret = true;
    num = 10;
    /*
    邏輯或 有真【即】真，同假為假
    邏輯或短路原則:
邏輯或表示式，出現 true 條件，整個表示式結果已明確為 true，計算機為了提高效率，從 true 條件開始，之後的表示式不再執行。
    */

2， 分支結構

2.1 if 分支

  // 格式:
  if (/* 條件判斷 boolean true or false */) {
      // if 之後為 true 執行大括號內容 
  }
  /*
  執行流程:
當前程式執行到 if 分支結構，首先判斷 if 之後的條件是否為 true，如果      為 true 執行大括號中的程式碼內容，如果為 false 跳過分支結構，執行之後的程式碼
    */


// if 分支結構
class Demo5 {
public static void main(String[] args) {
	// int num = 1;
	boolean flag = false;
	
	// if (num > 5) {
	if (flag) {
		System.out.println("我想吃擀麵皮");
	}
	
	System.out.println("螺洲螺螄粉+臭豆腐+鯡魚罐頭");
    }
  }

2.2 if else 分支

  // 格式
  if (/* 條件判斷 boolean true or false */) {
        // true 語句體
  } else {
        // false 語句體
  }
   /*
  執行流程:
  當前程式執行到 if else 分支結構，首先判斷 if 之後小括號裡面的內容是否為 true，如果為 true 執行 true 語句體，如果為 false 執行 false 語句體
   */


  // if else 分支結構
  class Demo6 {
  public static void main(String[] args) {
	boolean flag = false;
	
	if (flag) {
		System.out.println("z公交車 YYDS");
	} else {
		System.out.println("w公交表示不服");
	  }
    }
}

if else if 分支

 // 格式
 if (/* 條件匹配 1 */) {
      // 處理方式 1
  } else if (/* 條件匹配 2 */) {
       // 處理方式 2
  } else if (/* 條件匹配 3 */) {
       // 處理方式 3
  } else {
        // 無條件匹配的最終處理方式
}
   /*
  執行流程:
  當前程式執行到 if else-if 結構，匹配 if 之後的條件，如果有匹配項，執行對應處理方式，如果沒有任何一個條件匹配，執行 else 中的最終處理方式
例子： class Demo7 {
      public static void main(String[] args) {
	  int score = 59;
	
	  if (score >= 90) {
		System.out.println("秀兒");
	  }
	  } else if (score >= 70) {
		System.out.println("中兒");
	  } else if (score >= 60) {
		System.out.println("過兒");
	  } else {
		System.out.println("讓你爹學校一趟");
	  }
    }
  }