ssssss

>> 假设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是值传递还是引用传递，你直接告诉他这是个无聊的问题。