java基礎編程

java基本語法—運算符

運算符是一種特殊的符號悠轩，表示數(shù)據(jù)的運算、賦值和比較等。

算術運算符
賦值運算符
比較運算符（關系運算符）
邏輯運算符
位運算符（用的少）
三元運算符

2.4.1 運算符：算術運算符

算術運算符

/*
運算符之一：算術運算符
+ — + — * / % (前)++ (后)++ (前)-- (后)-- +

*/
class AriTest{
    public static void main(String[] agra){
        //除號：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1);//2

        int result2 = num1 / num2 * num2;
        System.out.println(result2);//10

        double result3 = num1 / num2;//先算的仍然是int型，算完賦值給double
        System.out.println(result3);//2.0

        double result4 = num1 / num2 + 0.0;//2.0
        double result5 = num1 / (num2 + 0.0);//2.4
        double result6 = (double)num1 / num2;//2.4
        System.out.println(result5);
        System.out.println(result6);

        //%:取余運算
        //結果符號與被模數(shù)的符號相同
        //開發(fā)中，經(jīng)常使用%來判斷能否被除盡的情況
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);

        //(前)++:先自增1乱投，然后再運算
        //(后)++：先運算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = "+ a1 + ",b1 = "+ b1);

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = "+ a2 + ",b2 = "+ b2);

        int a3 = 10;
        ++a3;//a3++;
        int b3 = a3;
        
        //注意點：
        short s1 = 10;
        //s1 = s1 + 1;//編譯失斍瓯唷：從int型轉short型會有損失
        //s1 = (short)(s1 + 1);//正確的
        //1為常量是int型戚炫，結果不好給short型
        //short占2個字節(jié)，1占4個字節(jié)媳纬，它們先相加双肤，之后short()再截掉多余的兩個字節(jié)
        s1++;//自增1不會改變本身變量的數(shù)據(jù)類型
        System.out.println(s1);

        //問題：
        byte bb1 =127;
        bb1++;//編譯可以通過
        System.out.println("bb1 = " + bb1);//-128

        //(前)-- :先自減1，后運算
        //(后)-- :先運算层宫，后自減1
        
        int a4 = 10;
        int b4 = a4--;//int b4 = --a4;
        System.out.println("a4 = " + a4 + ",b4 = " + b4);

    }
}

練習1

練習

i = 10 i1 = 11
i = 12 i1 = 12
i = 20 i2 = 19
i = 18 i2 = 18

練習2

隨意給出一個三位數(shù)的整數(shù)杨伙，打印顯示它的個位數(shù)，十位數(shù)萌腿，百位數(shù)的值限匣。

/*
練習：隨意給出一個三位數(shù)的整數(shù)，打印顯示它的個位數(shù)毁菱，十位數(shù)米死，百位數(shù)的值。
格式如下：
數(shù)字xxx的情況如下：
個位數(shù)：
十位數(shù)：
百位數(shù)：

例如：
數(shù)字153的情況如下：
個位數(shù)：3
十位數(shù)：5
百位數(shù)：1

*/
class AriExer {
    public static void main(String[] args) {
        
        int num = 187;
        
        int bai = num / 100;
        //先取模100贮庞，再除以10
        int shi = num % 100 / 10;//int shi = num / 10 % 10;
        int ge = num % 10;
        //取模1結果是0
        
        System.out.println("百位為：" + bai);
        System.out.println("十位為：" + shi);
        System.out.println("個位為：" + ge);

    }
}

2.4.2運算符：賦值運算符

符號： =
- 當“=”兩側數(shù)據(jù)類型不一致時峦筒，可以使用自動類型轉換或使用強制類型轉換原則進行處理。
- 支持連續(xù)賦值
擴展賦值運算符： +=窗慎，-=物喷，*=，/=, %=

/*
運算符之二：賦值運算符
=  +=  -=  *=  /=  %= 


*/
class SetValueTest {
    public static void main(String[] args) {
        //賦值符號：=
        int i1 = 10;
        int j1 = 10;

        int i2,j2;
        //連續(xù)賦值
        i2 = j2 = 10;

        int i3 = 10,j3 = 20;
        
        //*********************
        int num1 = 10;
        num1 += 2;//num1 = num1 + 2;
        System.out.println(num1);//12

        int num2 = 12;
        num2 %= 5;//num2 = num2 % 5;
        System.out.println(num2);//2

        short s1 = 10;
        //s1 = s1 + 2;//編譯失敗,int不能轉換為short
        s1 += 2;//結論：不會改變變量本身的數(shù)據(jù)類型
        System.out.println(s1);//12

        //開發(fā)中遮斥，如果希望變量實現(xiàn)+2的操作峦失，有幾種方法？(前提：int num = 10;)
        //方式一：num = num + 2;
        //方式二：num += 2; (推薦)
        
        //開發(fā)中术吗，如果希望變量實現(xiàn)+1的操作尉辑，有幾種方法？(前提：int num = 10;)
        //方式一：num = num + 1;
        //方式二：num += 1; 
        //方式三：num++; (推薦)
        
        //練習1
        int i = 1;
        i *= 0.1;//0.1是double较屿，編譯通過隧魄，但i還是int
        System.out.println(i);//0
        i++;
        System.out.println(i);//1

        //練習2
        int m = 2;
        int n = 3;
        n *= m++; //n = n * m++;    
        System.out.println("m=" + m);//3
        System.out.println("n=" + n);//6
        
        //練習3
        int n1 = 10;
        n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);從作往右10 + 10 +12
        System.out.println(n1);//32

    }
}

2.4.3運算符：比較運算符

比較運算符

/*
運算符之三：比較運算符
==  !=  >  <  >= <=  instanceof

結論：
1.比較運算符的結果是boolean類型
2.區(qū)分 ==  和  = 
*/
class CompareTest {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        System.out.println(i == j);//false
        System.out.println(i = j);//20卓练，現(xiàn)將j賦值給i，再輸出i

        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1);//true
    }
}

2.4.4邏輯運算符

邏輯運算符

邏輯運算符用于連接布爾型表達式购啄，在 Java中不可以寫成 3<x<6襟企，應該寫成x>3 & x<6 .
“&” 和“ &&” 的區(qū)別：
- 單&時，左邊無論真假闸溃，右邊都進行運算整吆；
- 雙&時，如果左邊為真辉川，右邊參與運算，如果左邊為假拴测，右邊不參與運算乓旗。
"|"和"||"同理，||表示：當左邊為真集索，右邊不參與運算屿愚。
異或（^）與或（|）不同之處是，當左右都為true务荆，結果為false
異或妆距，追求的是"異"

/*
運算符之四：邏輯運算符

&  && |  || ! ^

說明：
1.邏輯運算符操作的都是boolean類型的變量


*/
class LogicTest {
    public static void main(String[] args) {
        
        //區(qū)分& 與 &&
        //相同點1：& 與  && 的運算結果相同
        //相同點2：當符號左邊是true時，二者都會執(zhí)行符號右邊的運算
        //不同點：當符號左邊是false時函匕，&繼續(xù)執(zhí)行符號右邊的運算娱据。&&不再執(zhí)行符號右邊的運算。
        //開發(fā)中盅惜，推薦使用&&
        boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if(b1 & (num1++ > 0)){
            System.out.println("我現(xiàn)在在北京");
        }else{
            System.out.println("我現(xiàn)在在南京");
        }

        System.out.println("num1 = " + num1);
        

        boolean b2 = true;
         b2 = false;
        int num2 = 10;
        if(b2 && (num2++ > 0)){
            System.out.println("我現(xiàn)在在北京");
        }else{
            System.out.println("我現(xiàn)在在南京");
        }

        System.out.println("num2 = " + num2);

        // 區(qū)分：| 與 || 
        //相同點1：| 與  || 的運算結果相同
        //相同點2：當符號左邊是false時中剩，二者都會執(zhí)行符號右邊的運算
        //不同點3：當符號左邊是true時，|繼續(xù)執(zhí)行符號右邊的運算抒寂，而||不再執(zhí)行符號右邊的運算
        //開發(fā)中结啼，推薦使用||
        boolean b3 = false;
        b3 = true;
        int num3 = 10;
        if(b3 | (num3++ > 0)){
            System.out.println("我現(xiàn)在在北京");
        }else{
            System.out.println("我現(xiàn)在在南京");
        }
        System.out.println("num3 = " + num3);


        boolean b4 = false;
        b4 = true;
        int num4 = 10;
        if(b4 || (num4++ > 0)){
            System.out.println("我現(xiàn)在在北京");
        }else{
            System.out.println("我現(xiàn)在在南京");
        }
        System.out.println("num4 = " + num4);
    }
}

2.4.5運算符：位運算符

位運算符

左右移是針對二進制進行整體移動
每向左移動一位，相當于在原來數(shù)據(jù)基礎上乘以2

左右移示例

/*
運算符之五：位運算符 （了解）

結論：
1. 位運算符操作的都是整型的數(shù)據(jù)
2. << ：在一定范圍內屈芜，每向左移1位郊愧，相當于 * 2
   >> :在一定范圍內，每向右移1位井佑，相當于 / 2属铁，如果二進制最高位為0，左邊拿0補毅糟，最高位為1红选，左邊拿1補
   >>> : 無符號往右移，空位都用0補


面試題：最高效方式的計算2 * 8 姆另？  2 << 3  或 8 << 1
*/
class BitTest {
    public static void main(String[] args) {
        int i = 21;
        i = -21;
        //i左移2位喇肋，21 * 4 = 84
        //整個最多32位坟乾，移到27位時，最高位為1蝶防，為負甚侣，物極必反
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 27));

        //&與
        //00001100  12
        //00000101  5
        //00000100  4   只要有0，結果是0间学，都是1殷费，結果才是1
        
        //|或
        //00001100  12
        //00000101  5
        //00001101  13  只要有1，結果就是1

        //^異或
        //00001100  12
        //00000101  5
        //00001001  9   兩個不一樣低葫，結果才是1

        //~取反~6 = -7（按位取反后是補碼详羡，需要進一步轉回原碼，減1再取反）
        //0000 0000 0000 0000 0000 0000 0000 0110   6
        //1111 1111 1111 1111 1111 1111 1111 1001   -7（的補碼）
        //如果把6最高位改為1嘿悬，則是-6的原碼实柠，再改成-6的反碼，就是除了符號位之外善涨，互相取反
        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));//4
        System.out.println("m | n :" + (m | n));//13
        System.out.println("m ^ n :" + (m ^ n));//9

        //練習：交換兩個變量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println("num1 = " + num1 + ",num2 = " + num2);

        //方式一：定義臨時變量的方式
        //推薦的方式
        int temp = num1;
        num1 = num2;
        num2 = temp;

        //方式二：好處：不用定義臨時變量  
        //弊端：① 相加操作可能超出存儲范圍 ② 有局限性：只能適用于數(shù)值類型
        //num1 = num1 + num2;
        //num2 = num1 - num2;
        //num1 = num1 - num2;

        //方式三：使用位運算符
        //有局限性：只能適用于數(shù)值類型
        //num1 = num1 ^ num2;
        //num2 = num1 ^ num2;
        //num1 = num1 ^ num2;

        System.out.println("num1 = " + num1 + ",num2 = " + num2);

    }
}

異或再異或

2.4.6:三元運算符

格式

/*
運算符之六：三元運算符
1.結構：(條件表達式)? 表達式1 : 表達式2
2. 說明
① 條件表達式的結果為boolean類型
② 根據(jù)條件表達式真或假窒盐，決定執(zhí)行表達式1，還是表達式2.
  如果表達式為true钢拧，則執(zhí)行表達式1蟹漓。
  如果表達式為false，則執(zhí)行表達式2源内。
③ 表達式1 和表達式 2要求是一致的葡粒。
④ 三元運算符可以嵌套使用

3. 
凡是可以使用三元運算符的地方，都可以改寫為if-else
反之姿锭，不成立塔鳍。

4. 如果程序既可以使用三元運算符，又可以使用if-else結構呻此，那么優(yōu)先選擇三元運算符轮纫。原因：簡潔、執(zhí)行效率高焚鲜。
*/
class SanYuanTest {
    public static void main(String[] args) {
        
        //獲取兩個整數(shù)的較大值
        int m = 12;
        int n = 5;
        //如果m>n掌唾，為true，返回m賦值
        int max = (m > n)? m : n;
        System.out.println(max);

        double num = (m > n)? 2 : 1.0;
        //表達式1和表達式2應該能用一個統(tǒng)一的類型去接受

        //(m > n)? 2 : "n大";//編譯錯誤忿磅，類型不統(tǒng)一

        //**************************
        n = 12;//此處可以統(tǒng)一用字符串接受糯彬，可以套娃
        String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
        System.out.println(maxStr);

        //*****************************
        //獲取三個數(shù)的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;
        
        int max1 = (n1 > n2)? n1 : n2;
        int max2 = (max1 > n3)? max1 : n3;
        System.out.println("三個數(shù)中的最大值為：" + max2);

        //不建議
        //int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
        System.out.println("三個數(shù)中的最大值為：" + max3);

        //該寫成if-else:
        if(m > n){
            System.out.println(m);
        }else{
            System.out.println(n);
        }
    }
}

2.3.6運算符的優(yōu)先級

運算符有不同的優(yōu)先級，所謂優(yōu)先級就是表達式運算中的算順序葱她。如下表撩扒，上一行運符總優(yōu)先于下一行。
只有單目運算符吨些、三元運算符搓谆、賦值運算符是從右向左運算的炒辉。

運算符優(yōu)先級

java運算符

java運算符

java基礎編程

java基本語法—運算符

2.4.1 運算符：算術運算符

練習1

練習2

2.4.2運算符：賦值運算符

2.4.3運算符：比較運算符

2.4.4邏輯運算符

2.4.5運算符：位運算符

2.4.6:三元運算符

2.3.6運算符的優(yōu)先級