>> 假設a是一個被移位的整型數據，n是位移量。a>>n運算的結果是通過將a的所有位都右移n位，每右移一位，右邊的低階位上的0或1被移出丟棄，并用0或1填充左邊的高位。a是正數時用0填充，是負數時用1填充。更多細節請另行查閱。

>>> 假設a是一個被移位的整型數據，n是位移量。a>>>n運算的結果是通過將a的所有位都右移n位，每右移一位，右邊的低階位上的0或1被移出丟棄，并用0填充左邊的高位。更多細節請另行查閱。

&(&=) 按位與。

|(|=) 按位或。

^(^=) 按位異或，相同為0，不同為1。

按位運算符也可以操作邏輯型數據。按位運算的一個典型應用是定義一組常量，將2的不同倍數賦予每個常量：

// Bit field enumeration constants - OBSOLETE!
public class Text {
    public static final int STYLE_BOLD = 1 << 0; // 1
    public static final int STYLE_ITALIC = 1 << 1; // 2
    public static final int STYLE_UNDERLINE = 1 << 2; // 4
    public static final int STYLE_STRIKETHROUGH = 1 << 3; // 8
    
    // Parameter is bitwise OR of zero or more STYLE_ constants
    public void applyStyles(int styles) {
        if ((styles & STYLE_BOLD) == STYLE_BOLD) {
            System.out.println("bold");
        }
        if ((styles & STYLE_ITALIC) == STYLE_ITALIC) {
            System.out.println("italic");
        }
        if ((styles & STYLE_UNDERLINE) == STYLE_UNDERLINE) {
            System.out.println("underline");
        }
        if ((styles & STYLE_STRIKETHROUGH) == STYLE_STRIKETHROUGH) {
            System.out.println("strikethrough");
        }
    }
}

這種表示法允許你用按位或|運算符將幾個常量合并到一個表達式中，稱作位域（bit field）：

text.applyStyles(STYLE_BOLD | STYLE_ITALIC);

位域表示法也允許利用位運算符，執行聯合、差集以及交集等操作。

注意：Override可以減弱訪問權限，但不能增強。

#Todo#

Java允許通過標簽（結合關鍵字break和continue）實現流程控制，但最好不這樣做：

outer: while (...) {
    inner: for (...) {
        if (...) {
            break inner;
        }
        continue outer;
    }
}

語言層面上，相較于類，接口有著自己的一些特性。

接口的所有成員變量都是public static final的，無論你顯式聲明與否。為什么是這樣，引用SO上的兩個答案感受一下：

Protected methods are intended for sharing implementation with subclasses. Interfaces have nothing to offer as far as implementation sharing goes, because they have no implementation at all. Therefore all methods on interfaces must be public.

Because an interface is supposed to mean "what you can see from outside the class". It would not make sense to add non-public methods.

但是這里有個問題，因為Java 8支持接口提供默認的方法實現，這樣的話，如果一個接口是為了被其它接口繼承而設計的，受保護（protected）的方法是不是就有意義了呢？當然，這也是一種非常極端的用法，可能并不提倡。

接口的所有方法都是public abstract的，無論你顯式聲明與否；但Java 8 提供了接口方法的默認實現，叫做default方法，用關鍵字default作為修飾符來標識，這一定意義上破壞了這一約束。

接口本身是public abstract的，abstract修飾符被默認隱藏。

靜態代碼的真正意義是什么？靜態代碼是屬于類的代碼，即便對象不存在，屬于類的代碼也存在也可訪問，只要類已經被加載。#Todo#

Java是值傳遞還是引用傳遞？不知道這個問題有沒有使你感到困擾，但這個問題確實一直困擾著我，我覺得對象是引用傳遞，但是很多教科書式的答案都是說Java只有值傳遞，直到我讀到《Thinking in Java 4th Edition》里面的一段話，才豁然開朗：

This brings up the terminology issue, which always seems good for an argument. The term is "pass by value," and the meaning depends on how you perceive the operation of the program. The general meaning is that you get a local copy of whatever you’re passing, but the real question is how you think about what you’re passing. When it comes to the meaning of "pass by value," there are two fairly distinct camps:

Java passes everything by value. When you’re passing primitives into a method, you get a distinct copy of the primitive. When you’re passing a handle into a method, you get a copy of the handle. Ergo, everything is pass by value. Of course, the assumption is that you’re always thinking (and caring) that handles are being passed, but it seems like the Java design has gone a long way toward allowing you to ignore (most of the time) that you’re working with a handle. That is, it seems to allow you to think of the handle as "the object," since it implicitly dereferences it whenever you make a method call.

Java passes primitives by value (no argument there), but objects are passed by reference. This is the world view that the handle is an alias for the object, so you don’t think about passing handles, but instead say "I"m passing the object." Since you don’t get a local copy of the object when you pass it into a method, objects are clearly not passed by value. There appears to be some support for this view within Sun, since one of the "reserved but not implemented" keywords is byvalue. (There’s no knowing, however, whether that keyword will ever see the light of day.)


Having given both camps a good airing and after saying "It depends on how you think of a handle," I will attempt to sidestep the issue for the rest of the book. In the end, it isn"t that important – what is important is that you understand that passing a handle allows the caller’s object to be changed unexpectedly.

其實，對于Java這種純面向對象的語言，無所謂值傳遞還是引用傳遞，更準確的理解就是傳遞的就是那個對象，所以對傳遞進來的對象的修改，會反映到原來對象上，這就足夠了。只有在低級語言如C++才會需要明顯區分地址、引用和值這些概念，而對于高級的面向對象語言則完全是多此一舉。所以，如果以后有人問你Java是值傳遞還是引用傳遞，你直接告訴他這是個無聊的問題。