1.比較運算子

public static void main(String args[])
{
    int x = 3;
    int y = 4;
    int z = 5;
    System.out.println(x > y);
    System.out.println(x < y);
    System.out.println(x == y);
    System.out.println(x + y > x + z);
    System.out.println(x >= y);
    }
    基本的比較運算子便是  大於，小於，等於，大於等於，小於等於， 輸出結果也是看是否符合比較，符合便輸出true，不符合編書處flase；
 

2.賦值運算子

public static void main(String args[])
{
    int a = 20;
    System.out.println(a);
    int b = 10;
    System.out.println(b);
    System.out.println("----------------");
    int n;
    int m = n = 10;
    System.out.println((newStringBuilder("m:")).append(m).append(",n:").append(n).toString());
    System.out.println("-----------------");
    int y = 10;
    y += 20;
    System.out.println((new StringBuilder("y:")).append(y).toString());
}   

賦值運算子“=”
注意賦值時和其他運算子之間的優先順序；
+++++++
上述程式碼中的
(1).  new StringBuilder("內容 ")為匿名建立物件，而物件的內容便是雙引號中的內容;
(2). append（" "）是附加的意思，append方法中如果是自定義變數，則不需要加雙引號，如果是字串，則加雙引號;
 

(3). toString()這個方法它是一種物件型別，字串，不可變的，StringBuilder帶有緩衝區，通過它，可改變字串的這個不足的地方，如是我們用“+”來拼字串，這個過程中，會建立很多個字串物件，用StringBuilder,它就利用緩衝作用來完成這種工作，它與stringbuffer很類似，只是，它是執行緒非安全的，效率要比stringbuffer高些 ，在用append()附加字串，最後最好使用toString()方法將其變成一個完整的字串；

內容擴充：此時可以注意String型別，StringBuffer型別和StringBuilder型別的區別？
https://zhidao.baidu.com/question/1386767228469012700.html&gt;<br/

3.鍵盤錄入

public static void main(String args[])
{

    Scanner sc = new Scanner(System.in);
    System.out.println("請您輸入第一個資料:");
    int num1 = sc.nextInt();
    System.out.println("請您輸入第二個資料:");
    int num2 = sc.nextInt();
    int max = num1 <= num2 ? num2 : num1;
    System.out.println((new StringBuilder("您輸入的最大值是:")).append(max).toString());
    }

    如上述程式碼，先建立Scanner物件,建立物件時記得匯入Java.util.Scanner包,因為只有匯入這個包才可以建立Scanner物件,進而呼叫方法nextInt()獲取鍵盤錄入的內容;
    nextInt()代表獲取輸入的Int型物件;
    而程式碼中int max = num1 <= num2 ? num2 : num1;
    ?:其實是一個三目運算子;
    代表的意思是如果符合num1 <= num2,則輸出num2,否則輸出num1;輸出的順序看num2 : num1;如果想輸出最小數,為 int min = num1<=num2?num1:num2;

4.三目運算子
?:三目運算子,比較大小,類似於if(){}else{},如三所示
三目運算子比較兩數是否相等時
boolean flag = num1==num2?true:false;
改進後
boolean flag = num1==num2;即可

5.邏輯運算子

&和 | 既是邏輯運算子也是位運算子，而&&和||只是邏輯運算子。

同為邏輯運算子,他們的區別在哪裡??
（1）當&與&&同為邏輯運算子時，它們都用於連線兩個Boolean型別的表示式，當&和&&的兩端表示式同時為真時，表示式的結果為真，只要有一端為假，那麼表示式結果為假。從用法上來看，&和&&並沒有什麼區別，比如我們可以寫兩個表示式：

          3>5&3>2;       3>5&&3>2;

          兩個運算子都可以這麼用，但是不同的是，當在判斷這個表示式的真或假的時候，兩者的判斷次數不同；

         當使用&運算子： 計算機在判斷表示式的值的時候，先判斷3>5 的值為假，然後再判斷3>2的結果為真，於是最後的結果是 假&真 為假；

         但是當我們使用&&運算子的時候：計算機先判斷3>5 的值為假，此時表示式的結果一定為假，所以計算機就不再往下判斷了，判定表示式結果為假。

         邏輯運算子&與&&的區別是：

         & 無論左邊結果是什麼，右邊還是繼續運算；

         &&當左邊為假，右邊不再進行運算。

         但是兩者的結果是一樣的。

        （2）當|和||的兩端表示式同時為假時，表示式的結果為假，只要有一端為真，那麼表示式結果為真。

         所以同理，我們可以知道|與||的區別：

         | 無論左邊結果是什麼，右邊還是繼續運算；

         ||當左邊為真，右邊不再進行運算。

         但是兩者的結果是一樣的。

         所以&&和||是比較高效一些;

                     如程式碼所示:
                    public static void main(String args[])
{
    int a = 3;
    int b = 4;
    int c = 5;
    System.out.println(a > b & a > c);
    System.out.println(a > b && a > c);
    System.out.println(a < b && a > c);
    System.out.println(a < b && a < c);
    System.out.println("---------------------");
    int x = 3;
    int y = 4;
    boolean b1 = ++x == 3 && y++ == 4;
    System.out.println((new StringBuilder("x:")).append(x).toString());
    System.out.println((new StringBuilder("y:")).append(y).toString());
    System.out.println(b1);
}
輸出的前兩個雖然結果一樣,但是執行絕對不同;

!!!補充++x和x++的含義
++x會在本次執行中使x+1,進行改變;而x++則在本次執行中不改變;
如上述程式碼;++x==3,則x=4;  y++==4,則y還是4;

程式碼迷茫症狀易錯點:boolean b1 = 4&&4;應該為true,可為什麼執行結果為false?

其實是x=3,++x與3進行比較為false,所以結果為false;在這裡boolean b1 = ++x == 3 && y++ == 4;是個三目運算子,連線的是兩個boolean關係的表示式,雖然有&&,但是隻能代表&&左邊右邊分別為一個boolean的表示式;

6.算術運算子

• 加 -減 *乘 /除 %除 ++ --

  /和%的區別?
  比如 int a = 3 ; int b = 4;
  a/b=0; /代表取整數;
  a%b=3; /代表取餘數;

  如果要求出a/b的確切答案,最好定義int(整型)為double(雙精度型);如果定義的為int型,如上面運算,則進行強制轉換;
  強制轉換為double:   ((double)a*1.0d)/(double)b=0.75;
  1.0d代表的對double的生命,不加也不會出錯,最好加上,而前面的(double)代表強制轉換為double型別;
  
  如程式碼所示:
  
  public static void main(String args[])

  {

  int x = 3;
  int y = 4;
  int m = x++;
  int n = y--;
  System.out.println((new StringBuilder("x:")).append(x).toString());
  System.out.println((new StringBuilder("y:")).append(y).toString());
  System.out.println((new StringBuilder("m:")).append(m).toString());
  System.out.println((new StringBuilder("n:")).append(n).toString());

  }

  ++x會在本次執行中使x+1,進行改變;而x++則在本次執行中不改變;

  如上述程式碼;++x==3,則x=4; y++==4,則y還是4;

  則上述程式碼輸出結果為 x:4 y:3 m:3 n:4
  原因是x++ 中x並沒有先+,而是先給m賦值,所以m為3,之後x自行加1,則x為4,y同理.

  7.流程控制語句

  (1)順序結構 從上往下，依次執行
  (2)選擇結構 按照不同的選擇，執行不同的程式碼
  (3)迴圈結構 做一些重複的程式碼

  if語句

  **格式:
  if(條件){滿足條件後的執行語句};(1)
  else if(條件){滿足條件後的執行語句};(2)
  else{不滿足上述條件的其他所有情況的執行語句};(3)
  上述三行第一行單獨是一種格式,第一行和第三行合起來是一種格式,三行一起是一種格式;
  注意點:
  A:比較表示式無論簡單還是複雜，結果是boolean型別
  B:if語句控制的語句體如果是一條語句，是可以省略大括號的；如果是多條，不能省略。
  建議：永遠不要省略。
  C:一般來說，有左大括號，就沒有分號，有分號，就沒有左大括號。
  D:else後面如果沒有if，是不會出現比較表示式的。
  E:三種if語句其實都是一個語句，只要有一個執行，其他的就不再執行。

**如果執行語句只有一句,可以不加{};
如程式碼:
public static void main(String args[])
{
int x = 10;
if(x!=10)
System.out.println("x等於10");
if (x == 20)
System.out.println("x等於20");
System.out.println("over");
}
執行結果:over

**易錯點,小心;的新增,上述程式碼,如果給if(x!=10)後面加;  ,會出現如下情況

    public static void main(String args[])
{
    int x = 10;
    if (x != 10);
    System.out.println("x等於10");
    if (x == 20)
        System.out.println("x等於20");
    System.out.println("over");
}
    運算結果:x等於10    over
    *為什麼?
    此時的分號可以讓此次if語句無效,則會直接輸出,然後進入下次的if語句;

    switch語句

    **格式：
    switch(表示式) {
        case 值1:
            語句體1;
            break;
        case 值2:
            語句體2;
            break;
        ...
        default:
            語句體n+1;
            break;
    }

    **格式解釋說明：
        switch:說明這是switch語句。
        表示式:可以是byte,short,int,char
            JDK5以後可以是列舉
            JDK7以後可以是字串
        case:後面的值就是要和表示式進行比較的值
        break:表示程式到這裡中斷，跳出switch語句
        default:如果所有的情況都不匹配,就執行這裡,相當於if語句中的else

                **小問題: switch語句的表示式可以是byte嗎?可以是long嗎?可以是String嗎?
        可以,不可以,JDK7以後可以

**執行流程:
A:首先計算表示式的值
B:和每一個case進行匹配，如果有就執行對應的語句體，看到break就結束。
C:如果沒有匹配，就執行default的語句體n+1。

            **注意事項:
    A:case後面只能是常量，不能是變數，而且，多個case後面的值不能出現相同的
    B:default可以省略嗎?
        可以省略，但是不建議，因為它的作用是對不正確的情況給出提示。
        特殊情況：
            case就可以把值固定。
            A,B,C,D
    C:break可以省略嗎?
        可以省略，但是結果可能不是我們想要的。
        會出現一個現象：case穿透。
        最終我們建議不要省略
    D:default一定要在最後嗎?
        不是，可以在任意位置。但是建議在最後。
    E:switch語句的結束條件
        a:遇到break就結束了
        b:執行到末尾就結束了

            ****if語句和switch語句各自的場景
    A:if
        針對boolean型別的判斷
        針對一個範圍的判斷
        針對幾個常量的判斷
    B:switch
        針對幾個常量的判斷

    **下面對迴圈語句做出解釋:
    for,while,do...while

    **for迴圈語句
    A:格式
        for(初始化語句;判斷條件語句;控制條件語句){
            迴圈體語句;
        }

     **執行流程：
            a:執行初始化語句
            b:執行判斷條件語句
                如果這裡是true，就繼續
                如果這裡是false，迴圈就結束
            c:執行迴圈體語句
            d:執行控制條件語句
            e:回到b
     **B:注意事項
        a:判斷條件語句無論簡單還是複雜，結果是boolean型別
        b:迴圈體語句如果是一條，可以省略大括號，但是不建議
        c:有分號就沒有左大括號，有左大括號就沒有分號

                    **while迴圈
    **A:基本格式
        while(判斷條件語句) {
            迴圈體語句;
        }

     **擴充套件格式：
        初始化語句;
        while(判斷條件語句){
            迴圈體語句;
            控制條件語句;
        }

        通過檢視這個格式，我們就知道while迴圈可以和for迴圈等價轉換。

            **for和while的區別
        **a:使用上的區別
            for語句的那個控制條件變數,在迴圈結束後不能在使用了。
            而while的可以繼續使用。
        b:理解上的區別
            for適合於一個範圍的判斷
            while適合次數不明確的

                **do...while迴圈
   ** A:基本格式
        do {
            迴圈體語句;
        }while(判斷條件語句);

        **擴充套件格式：
        初始化語句;
        do {
            迴圈體語句;
            控制條件語句;
        }while(判斷條件語句);

        通過檢視格式，我們就可以看出其實三種迴圈的格式可以是統一的。
   ** B:三種迴圈的區別
        a:do...while迴圈至少執行一次迴圈體
        b:for和while必須先判斷條件是否是true，然後後才能決定是否執行迴圈體

         **迴圈使用的注意事項(死迴圈)
    A:一定要注意修改控制條件,否則容易出現死迴圈。
    B:最簡單的死迴圈格式
        a:while(true){...}

        b:for(;;){}