Java編程思想-操作符

在最底層,Java中的數據是通過使用操作符來操作的。

使用Java操作符

操作符接受一個或多個參數,並生成一個新值。參數的形式與普通的方法調用不同,但效果是相同的。加號和一元的正號(+), 減號和一元的符號(-), 乘號(*) ,除號(/) 以及賦值號(=)的用法與其他編程語言類似。
操作符作用於操作數,生成了一個新值。另外,有些操作符可能會改變操作數自身的值, 這被稱爲副作用。那些能改變其操作數的操作符,最普遍的用途就是產生副作用,但要記住,使用此類操作符生成的值,與使用沒有副作用的操作符生成的值,沒有什麼區別。
幾乎所有的操作符都只能操作基本數據類型。例外的操作符是 = ,== , != 這些操作符能操作所有的對象。除此以外,String 類支持 + 和 +=。

優先級

當一個表達式中存在多個操作符時,操作符的優先級就決定了各部分的計算順序。Java對計算順序做了特別的規定,其中,最簡單的規則就是先乘除後加減。程序員會經常忘記其他優先規則,所以應該用括號明確規定計算順序。

    public static void main(String[] args) {
     int x=1;int y=2;int z=3;
     int a=x+y-2/2+z;
     int b=x+(y-2)/(2+z);
        System.out.println(a); //result 5
        System.out.println(b);//result 1
    }

注意 : 這倆個語句看起來大體相同,但是從輸出就可以看出它們具有迥然不同的含義,而這正是使用括號的結果。

賦值

=賦值使用操作符 = 。它的意思是取右邊的值(即右值),把它複製給左邊(即左值)。右值可以是任何常數,變量或者表達式(只要它能生成一個值就行)。但左值必須是一個明確的,已命名的變量。也就是說,必須有一個屋裏空間可以存儲等號右邊的值。舉例來說,可將一個常數賦給一個變量:

a=4;

但是不能把任何東西賦給一個常數,常數不能作爲左值例如(4=a)
對基本數據類型的賦值是很簡單的。基本類型存儲了實際的數據,而並非指向了一個對象的引用,所以在爲其賦值的時候,是直接將一個地方的內容複製到了另一個地方。例如,對基本數據類型使用 a=b,那麼b的內容就複製給a ,若接着又修改了a,而b根本不會受這種修改的影響。

public class AllTheColorsOfTheRainbow {
    int anIntegerRepresentingColors;

    public static void main(String[] args) {
        AllTheColorsOfTheRainbow allTheColorsOfTheRainbow1 = new AllTheColorsOfTheRainbow();
        AllTheColorsOfTheRainbow allTheColorsOfTheRainbow2 = new AllTheColorsOfTheRainbow();
        allTheColorsOfTheRainbow1.anIntegerRepresentingColors=20;
        allTheColorsOfTheRainbow2.anIntegerRepresentingColors=30;
        System.out.println("1==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("1==>1allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);

        allTheColorsOfTheRainbow1=allTheColorsOfTheRainbow2;
        System.out.println("2==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("2==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);

        allTheColorsOfTheRainbow1.anIntegerRepresentingColors=25;
        System.out.println("3==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow1.anIntegerRepresentingColors);
        System.out.println("3==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:"+allTheColorsOfTheRainbow2.anIntegerRepresentingColors);
    }
}


//運行結果爲
1==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:20
1==>1allTheColorsOfTheRainbow2.anIntegerRepresentingColors:30
2==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:30
2==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:30
3==>allTheColorsOfTheRainbow1.anIntegerRepresentingColors:25
3==>allTheColorsOfTheRainbow2.anIntegerRepresentingColors:25

AllTheColorsOfTheRainbow 類非常簡單,它的倆個實例 (allTheColorsOfTheRainbow1和allTheColorsOfTheRainbow2)都是在main()創建的。對於每個 AllTheColorsOfTheRainbow 類對象的 anIntegerRepresentingColors 域都賦予了一個不同的值,然後 allTheColorsOfTheRainbow2 賦給 allTheColorsOfTheRainbow1 ,接着又修改了 allTheColorsOfTheRainbow1。
在許多編程語言中,我們可能會期望 allTheColorsOfTheRainbow2 和 allTheColorsOfTheRainbow1總是相互獨立的。但由於賦值操作是一個對象的引用,所以修改 allTheColorsOfTheRainbow1的同時也改變了 allTheColorsOfTheRainbow2! 這是由於allTheColorsOfTheRainbow1 和 allTheColorsOfTheRainbow2包含相同的引用,它們指向相同的對象。(原本 allTheColorsOfTheRainbow1 包含的對對象的引用,是指向一個值爲20的對象。在堆allTheColorsOfTheRainbow1 賦值的時候,這個引用被覆蓋,也就是數據丟失了,而那個不在被引用的對象會由垃圾回收器自動清理。)
這種特殊的現象通常稱作別名現象,是Java操作對象的一種基本方式。在這個例子中,如果想避免別名問題,應該怎麼辦呢?可以這樣寫

allTheColorsOfTheRainbow1.anIntegerRepresentingColors=allTheColorsOfTheRainbow2.anIntegerRepresentingColors;

這樣便可以保持倆個對象彼此獨立。而不是 allTheColorsOfTheRainbow1 和 allTheColorsOfTheRainbow2綁定到相同的對象。但你很快就會意識到,直接操作對象內的作用域容易導致混亂,並且,違背了良好的面向對象程序設計的原則。這可不是一個小問題,所以從現在開始大家就應該留意,爲對象賦值可能會產生意想不到的結果。

方法調用中的別名問題

當一個對象傳遞給方法時,也會產生別名問題:

public class PassObject {
    static void letterMethod(Letter letter){
        letter.field='h';
    }
    public class Letter{
        char field;
    }
    public static void main(String[] args) {
        PassObject passObject = new PassObject();
        //創建內部類對象
        PassObject.Letter letter = passObject.new Letter();
        letter.field='a';
        System.out.println("1==>letter.field:"+letter.field);

        letterMethod(letter);
        System.out.println("2==>letter.field:"+letter.field);
    }
}
//運行結果爲
1==>letter.field:a
2==>letter.field:h

在許多編程語言中,方法letterMethod()似乎要在它的作用域內複製其參數 Letter letter的一個副本,但實際上只是傳遞了一個引用。所以代碼行

letter.field='h';

實際改變的是 letterMethod()之外的對象。

算術操作符

Java 的基本算術操作符與其他大多數程序設計語言是相同的。其中包括加號(+),減號(-),除號(/),乘號(*)以及取模操作符(%,它從整數除法中產生餘數)。整數除法會直接去結果的小數位,而不是四捨五入地圓整結果。
Java 也使用一種來自C和C++的簡化符號同時進行運算與賦值操作。這用操作符後緊跟一個等號來表示,它對於Java 中的所有操作符都適用,值要其有實際意義就行。例如, 要將 x加4,並將結果賦回給x,可以這麼寫:x+=4。
Random類的對象,程序可生成許多不同類型的隨機數字。Random類有方法 nextInt()和 nextFloat()即可

一元加,減,操作符

一元減號(-)和一元加號(+)與二元減號和加號都是用相同的符號。根據表達式的書寫形式,編譯器會自動判斷出使用的是哪一種。例如語句

x = -a;
//的含義是顯然的,編譯器能正確識別下述語句。

x = a * -b;

//但是讀者會被搞糊塗,所以有時更明確地寫成:
x = a * (-b);

一元減號用於轉變數據的符號,而一元加號只是爲了與一元減號相對應,但是它唯一的作用僅僅是將較小類型的操作數提升爲int。

自動遞增和遞減

和C類似,Java提供了大量的快捷運算。這些快捷運算使編碼更方便,同時也使代碼更容易閱讀,但是有時可能使代碼閱讀起來更困難。
遞增和遞減運算是倆種相當不錯的快捷運算(常被稱爲自動遞增和自動遞減運算)。其中,遞減操作符 -- 意爲減少一個單位. 遞增操作符是 ++ 意爲增加一個單位。舉個例子來說,假設a是一個int值,則表達式 ++a 就等同於 a=a+1 。遞增和遞減操作符不進改變了變量,並且以變量的值作爲生成的結果。
這倆個操作符各有倆種使用方式,通常稱爲前綴式和後綴式

前綴遞增表示 ++ 操作符位於變量或者表達式前面。類似於前綴遞減意爲着 -- 操作符位於變量或者表達式前面。
後綴遞增表示 ++ 操作符位於變量或表達式的後面。類似於後綴遞減意爲着-- 操作符位於變量或者表達式後面。

對於前綴遞增和前綴遞減(如 ++a / --a) 會先執行運算,在生成值。
對於後綴遞增和後綴遞減(a++ / a--)會先生成值,在執行運算。

        int a=1;
        int b=a++;
        System.out.println("a:"+a);  //a=2
        System.out.println("b:"+b); //b=1
        int c=1;
        int d=++c;
        System.out.println("c:"+c); //c=2
        System.out.println("d:"+d); //d=2
        
        int e=1;
        e=e++;
        System.out.println("e:"+e); //e=1
        
        int f=1;
        f=++f;
        System.out.println("f:"+f); //2

e並沒有給我們想一樣進行自增!
原因: ++(--) 操作是具有返回值的,當 ++(--) 在變量前面的時候返回值爲自增(自減)後面的值,當++(--)在變量後面的時候返回值爲自增(自減)前面的值,在 e=e+1時,e++返回值爲1,所以e沒有變化。
在實際開發過程中++(--)在變量後的情況儘量不要把結果賦值給其他變量。

關係操作符

關係操作符生成的是一個boolean(布爾)結果,它們計算的是操作數的值之間的關係。如果關係是真實的,關係表達式會生成true(真),如果關係是不真實,則會生成false(假)。關係操作符包括小於(<) , 大於(>) , 小於或等於(<=) ,大於或等於(>=) , 等於(==) 一級不等於(!=)。

    public static void main(String[] args) {
    Integer integer1=new Integer(47);
    Integer integer2=new Integer(47);
        System.out.println(integer1 == integer2);  //false
        System.out.println(integer1 != integer2);  //true
    }

你可能覺得輸出的結果肯定先是 true 再是false ,因爲倆個Integer 對象都是相同的,但是儘管對象的內容相同,然而對象的引用卻是不同,而 == 和 != 比較的就是對象的引用。所以輸出實際結果先是 false 後是 true 。
如果你想比較倆個對象的實際內容是否相同,又該如何操作呢?如下

    public static void main(String[] args) {
    Integer integer1=new Integer(47);
    Integer integer2=new Integer(47);
        System.out.println(integer1.equals(integer2));   //true
    }

結果正如我們所料想那樣爲true,但是事情並沒有那麼簡單,加入自己創建一個類,然後equals判斷是否相同如下

public class Calculation {
    int number;
    public static void main(String[] args) {
        Calculation calculation1=new Calculation();
        Calculation calculation2=new Calculation();
        calculation1.number=20;
        calculation2.number=20;
        System.out.println(calculation1.equals(calculation2)); //false
    }
}

事情再次變得令人費解? 結果又是false ,這是由於equals的默認行爲是比較引用所以除非在自己的新類中覆蓋equals方法,否則不可能表現出我們希望的行爲。
如上 Integer 類中重寫了 Object 的equals方法如下

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

所以如果你想在自己創建的新類判斷是否相同,也需要重寫equals方法

邏輯操作符

邏輯操作符與(&&) , 或 (||) , 非(!) 能根據參數的邏輯關係,生成一個布爾值 (true 或者 false)
與 , 或 ,非只能用於布爾值。與C及C++中不同的是:不可將一個非布爾值當作布爾值在邏輯表達式中使用。

短路

當使用邏輯操作符時,我們會遇到一種短路現象。即一旦能夠明確無誤地確定整個表達式的值,就不再計算表達式餘下部分了。因此,整個邏輯表達式靠後的部分有可能不會被運算。

直接常量

一般來說,如果程序裏使用了直接常量 ,編譯器可以準確地知道要生成什麼樣的類型,但有時候卻是模棱兩可的,如果發生這種情況,必須對編譯器加以適當的指導們用與直接量相關的某些字段來額外增加一些信息。
直接常量後面的後綴字符標誌了它的類型。若爲大寫(或小寫)的L 則表示long(但是,使用小寫字母I 容易造成混淆,因爲它看起來很像數字1)。大寫(或小寫)字母F則表示float, 大寫(或小寫)字母D,則表示 double。
十六進制數適用於所有證書數據類型,以前綴0x(或0X),後面跟隨0-9或小寫(或大寫)的a-f來表示。如果試圖將一個變量初始化成超出自身表示範圍的值(無論這個值得數值形式如何),編譯器都會向我們報告一條錯誤信息。
八進制數由前綴0以及後續的0-7的數字來表示。
在C,C++或者Java中,二進制數沒有直接常量表示方法。但是,在使用十六進制和八進制記數法時,以二進制形式顯示結果將非常有用。通過Integer 和 Long類的靜態方法 toBinaryString()可以很容易實現這一點。

按位操作符

按位操作符用來操作證書基本數據類型中的單個比特 ,即二進制位。按位操作符會對倆個參數中對應的位執行布爾代數運算,並生成一個最終結果。
按位操作符來源於C語言面向底層的操作,在這種操作中經常需要直接操縱硬件,設置硬件寄存器內的二進制。Java的設置初衷是嵌入電視機機頂盒內,所以這種面向底層的操作人唄保留了下來。但是,人們可能不會過多地用到位操作符。
如果倆個輸入位都是1 ,則按位與(&) 生成一個輸出位1,否則生成一個輸出位0。如果倆個輸入位只要有一個1,則按位或(|)生成一個輸出位1。只要兩個輸入位都是0的情況下,他纔會生成一個輸出位0。如果輸入位的某一個是1,但不全都是1,那麼按位異或(^)會生成一個輸出位1。按位非(~) 也被稱爲取反操作符,它屬於一元操作符,只對一個操作數進行操作(其他按位操作符是二元操作符)。按位非生成與輸入位相反的值 __若輸入0,則輸出1 ,若輸出1 則返回0。

        //按位 &
        System.out.println(1&1); //result 1
        System.out.println(1&0); //result 0
        System.out.println(0&0); //result 0

        //按位 |
        System.out.println(0|1);//result 1
        System.out.println(0|0);//result 0
        System.out.println(1|1);//result 1

        //按位 異或 ^
        System.out.println(1^0); //1
        System.out.println(1^1); //0
        System.out.println(0^0); //0

按位操作符和邏輯操作符都使用了同樣的符號,因此我們能方便地記住它們的含義:由於位是非常小的,所以按位操作符僅使用了一個字符。
按位操作符可與等號(=)聯合使用,以便合併運算和賦值: &=,!=和^=都是合法的(由於~ 是一元操作符,所以不可與 = 聯合使用)

移位操作符

官方文檔說明
移位操作符操作的運算對象也是二進制的位。移位操作符只可用來處理整數類型(基本類型的一種)。左移位操作符(<<)能按照操作符右側指定的位數將操作符左邊的操作數向左移動(在低位補0)。有符號右移操作符(>>) 則按照操作符右側指定的位數將操作符左邊的操作數向右移動。
有符號右移操作符使用符號擴展,若符號爲正,則在高位插入0,若符號爲負,則高位2插入1,Java中增加了一種無符號右移操作符(>>>)它使用零擴展,無論正負,都在高位插入0。這一操作符是C和C++中所沒有的。
如果對char , byte 或者 short 類型的數值進行移位處理, 那麼再移位之前,它們會被轉換成int類型,並且得到的結果也是一個int類型的值。
移位可以與等號 (<<= 或 >>= 或 >>>=) 組合使用。此時,操作符左邊的值會移動由右邊的值指定位數,再將的到的結果賦給左邊的變量,再將得到的結果賦給左邊的變量。
簡單理解就是
移位運算符是位操作符的一種。移位運算符可以在二進制的基礎上對數字進行平移。按照平移的方法和填充數字的規則分爲三種

<< : 左移運算符 ,例如 a<< 1 相當於 a*2
>> : 右移運算符,例如 a>>1 相當於 a/2
>>> : 無符號右移,忽略符號位,空位都以0補齊。(計算機中數字以補碼存儲,首位爲符號位)
例如

    public static void main(String[] args) {
        //Integer.toBinaryString()是將數字用二進制格式顯示
        
        //右移運算符
        System.out.println(Integer.toBinaryString(-10>>2));
        //左移位移符
        System.out.println(Integer.toBinaryString(-10<<2));
        //無符號右移
        System.out.println(Integer.toBinaryString(-10>>>2));


        //運行結果爲
        11111111111111111111111111111101
        11111111111111111111111111011000
        111111111111111111111111111101(省略了首位倆個0)
    }

字符串操作符+和+=

這個操作符在Java中有一項特殊用途: 連接不同的字符串。
字符串操作有一些很有趣的行爲。如果表達式以一個字符串起頭,那麼後續所有操作數都必須是字符串型(請記住,編譯器會把雙引號內的字符序列自動轉成字符串)如下

    public static void main(String[] args) {
        int x=0;
        int y=1;
        int z=2;
        String str="x,y,z";
        //result x,y,z012
        System.out.println(str+x+y+z);
        //result 0 x,y,z
        System.out.println(x+" "+str);
        str +="(summed)= ";
        //result x,y,z(summed)= 3
        System.out.println(str+(x+y+z));
        //result  0
        System.out.println(" "+x);
    }

三元此操作符if-else

三元操作符也被稱爲條件操作符,它顯得比較特別,因爲它有三個操作數,但它確實屬於操作符的一種因爲它最終也會生成一個值,其表達式如下

boolean-exp? value0 : value1

如果 boolean-exp(布爾表達式)的結果爲true,就計算 value0 ,而且這個計算結果也就是操作符最終產生的值,如果boolean-exp的結果爲false,就計算value1,同樣,它的結果也就成爲了操作符最終產生的值。
當然,也可以換用普通的if-else,但三元操作符更加簡潔。儘管C(C中發現了該操作符)引以爲傲的就是它是一種簡練的語言,而且三元操作符的引入多半就是爲了體現這種高效率的編程,但假如你打算頻繁使用它,還是要多作思量,因爲它很容易產生永恆可讀性極差的代碼。
條件操作符與if-else完全不同,因爲它會產生一個值。如下進行比較

public class Calculation {
    static int sumResult(int i){
        return i<10 ? i*10 :i*100;
    }

    static int staticSumResult(int i){
        if (i<10){
            return i*10;
        }else {
            return i*100;
        }
    }

    public static void main(String[] args) {
        System.out.println(sumResult(9));//90
        System.out.println(sumResult(10));// 1000
        System.out.println(staticSumResult(9));//90
        System.out.println(staticSumResult(10));//1000
    }
}

我們可以看出 sumResult() 中代碼與 staticSumResult()中不用三元操作符的代碼相比,顯得更加緊湊,但staticSumResult()更易理解,而且不需要太多的錄入,所有在使用三元草自作符時,請務必仔細考慮。

使用操作符時常犯的錯誤

使用操作符時一個常犯的錯誤就是,即使對錶達式如何計算有點不確定,也不願意使用括號。這個問題在Java中仍然存在。
在C和C++中,一個特別常見的錯誤如下:

while(x = y){
//...
}

程序員很明顯是想測試是否相等(==),而不是進行賦值操作。在C和C++中,如果y是一個非零值,那麼這種賦值的結果肯定是true,而這樣便會得到一個無窮循環。在Java中,這個表達式的結果並不是布爾值,而編譯器期望的是一個布爾值。由於Java不會自動地將int數值轉換成布爾值,所以在編譯時會拋出一個編譯時錯誤,從而阻止我們進一步去運行程序。所以這種情況在Java中永遠不會出現(唯一不會得到編譯時錯誤的情況是x和y都爲布爾值。在這種情況下,x=y屬於合法表達式。而在前面表達式例子中,則可能是一個錯誤)。
Java中有一個與C和C++類似的問題,即使用按位與和按位或代替邏輯與和邏輯或。按位與和按位或使用單字符(&或|) ,而邏輯與和邏輯或使用雙字符 (&& 或||) 就像 = 和 == 一樣,鍵入一個字符當然要比鍵入倆個簡單。Java編譯器可防止這個錯誤發生,因爲它不允許我們隨便把一種類型當做另一種類型來用。

類型轉換操作符

類型轉換(cast)的原意是模型鑄造。在適當的時候,Java會將一種數據類型自動轉換成另一種,例如,假設我們爲某浮點變量賦以一個整數值,編譯器會將int 自動轉換成float。類型轉換運算允許我們顯式地進行這種數據的轉換,或者在不能自動進行轉換的時候強制進行類型轉換。
要想執行類型轉換,需要將希望得到的數據類型置於圓括號內,放在要進行類型轉換的值左邊如int a=1; Long b=(Long)a;
在Java中,類型轉換則是一種比較安全的操作。然而,如果,要執行一種名爲窄化轉換的操作(也就是說,將能容納更多的數據類型轉換成無法容納那麼多信息的類型,可能面臨信息丟失的危險。此時,編譯器會強制我們進行類型轉換,這實際上是說這可能是一件危險的事情,如果無論如何要這麼做,必須顯式地進行類型轉換,而對於擴展轉換,則不必顯式地進行類型轉換,因爲新類型肯定能容納原來類型的信息,不會造成任何信息的丟失。
Java中允許我們把任何基本數據類型轉換成別的基本數據類型,但布爾類型除外,後者根本不允許進行任何類型的轉換處理。類數據類型不允許進行類型轉換。爲了將一種類轉換成另一種必須採用特殊的方法。

截尾和舍入

在執行窄化轉換時,必須注意截尾和舍入問題。例如,如果將一個浮點值轉換爲整數值,Java會如何處理呢?如下

       double dou1=0.4d;
       double dou2=0.7d;
       float flo1=0.4f;
       float flo2=0.7f;
        System.out.println((int)dou1);//0
        System.out.println((int)dou2);//0
        System.out.println((int)flo1);//0
        System.out.println((int)flo2);//0

因此答案是在 float 或 double 轉型爲整型值時,總是對該數字執行截尾。如果想要得到舍入的結果,就需要使用java.lang.Math中的rund()方法:

    public static void main(String[] args) {
       double dou1=0.4d;
       double dou2=0.7d;
       float flo1=0.4f;
       float flo2=0.7f;

        System.out.println(Math.round(dou1));// 0
        System.out.println(Math.round(dou2));// 1
        System.out.println(Math.round(flo1));// 0
        System.out.println(Math.round(flo2));// 1

    }

提升

如果對基本數據類型執行算術運算或按位運算,大家會發現,只要類型比int小(即char,byte或者short),那麼再運算之前,這些值會自動轉換成int 。這樣一來,最終生成的結果就是int類型。如果想把結果賦值給較小的類型,就必須使用類型轉化(即然把結果賦給了較小的類型,就可能出現信息丟失)。通常,表達式中出現的最大的數據類型決定了表達式最終結果的數據類型。如果將一個float值與一個double值相乘,結果就是 double ,如果將一個int 和一個long值相加 ,則結果爲long。

Java沒有sizeof

在C和C++中,sizeof()操作符可以告訴你爲數據項分配的字節數。在C和C++中,需要使用 sizeof()的最大原因是爲了移植 ,不同的數據類型在不同的機器上可能有不同的大小,所以在進行一些與存儲空間相關的運算時,程序員必須獲悉那些類型具體有多大。例如,一臺計算機可用32位來保存整數,而另外一臺只用16位保存。顯然,在第一臺機器中,程序可保存更大的值。可以想象,移植是令C和C++程序員頗爲頭疼的一個問題。
Java不需要使用sizeof()操作符來滿足這方面的需求,因爲所有數據類型在所有機器中的大小都是相同的。我們不必考慮移植問題__它已經被設計在語言中了。

總結

如果你擁有編程語言的經驗,那麼只要它的語法類似於C,你就會發現Java中的操作符與它們是多麼的相似,以至於對你來說沒有任何學習困難。
本章學了 Java操作符 +,-,*,/ 操作符的優先級,可以使用括號來明確計算順序,使用 = 進行賦值, 算術操作符有學習了 %(取模),一元加減操作符 , 自動遞增和遞減 ++a --a 與 a++ ,a-- (前綴遞增/遞減-->先運算後賦值反之後綴遞增/遞減先賦值後運算),
又學了關係操作符 < , > , <= , >= ,== 以及 != 還學了邏輯操作符 &&(邏輯與) , ||(邏輯或) 和 ! (邏輯非
又學了按位操作符 &(按位與) , |(按位或) ,^(按位異或) 和 ~(按位非) ,接下來移位操作 << (左移操作符),>> (右移操作符) ,>>>(無符號操作符) ,其中又學了三元操作符if-else,請謹慎使用三元操作符。
類型轉換操作符 (cast), Java中沒有sizeof()方法

Java編程思想-操作符

使用Java操作符

優先級

賦值

方法調用中的別名問題

算術操作符

一元加,減,操作符

自動遞增和遞減

關係操作符

邏輯操作符

短路

直接常量

按位操作符

移位操作符

字符串操作符+和+=

三元此操作符if-else

使用操作符時常犯的錯誤

類型轉換操作符

截尾和舍入

提升

Java沒有sizeof

總結

druid數據源 xml配置

利用BootStrap創建搜索框--」詳解

Java編程思想__泛型(五)

RabbitMQ的主題模式(Topic)

springCloud之熔斷器Hystrix

SpringCloud微服務網關Zuul

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結