十大遗珠之憾

10 位操作

byte有8位，short有16位，int有32位
按位非运算符：~
0变1,1变0
int x = 10;//位组合00001010
x = ~x;//位组合11110101
按位与运算符：&
两个位都为1，结果才为1
int x = 10;//位组合00001010
int y = 6;//位组合00000110
int a = x & y;//位组合00000010
按位或运算符：|
两个位都为0，结果才为0
int x = 10;//位组合00001010
int y = 6;//位组合00000110
int a = x | y;//位组合00001110
按位异或运算符：^
两个位相同为0，不相同为1
int x = 10;//位组合00001010
int y = 6;//位组合00000110
int a = x ^ y;//位组合00001100
负数的二进制：
负数的二进制位组合等于正数的二进制位组合非运算后加1
int x = 11;//位组合00001011
int y = -11;//位组合11110101
左移运算符：
各二进位全部左移若干位，高位丢弃，低位补0，正负号可能改变
int x = -11;//位组合11110101
int y = x << 2;//位组合11010100
算术右移运算符：
各二进位全部右移若干位，对无符号数，高位补0，有符号数补符号位，正负号不变
int x = -11;//位组合11110101
int y = x >> 2;//位组合11111101
逻辑右移运算符(无符号右移运算符)：
各二进位全部右移若干位，对无符号数，高位补0，有符号数，高位也补0
int x = -11;//位组合11110101
int y = x >>> 2;//位组合00111101

9 不变性

String和包装类有具有不变性，对象创建后就无法改变该对象的值

8 断言

断言用来帮助你在开发过程中除错，使用方式和println()差不多
assert (height > 0);
// if true, program continues normally
// if false, throw an AssertionError
也可以利用断言加上一点信息：
assert (height > 0) : “height = “ + height + “ weight = “ + weight;
带有断言的编译(没有什么不一样)：
javac TestDriveGame.java
带有断言的执行：
java -ea TestDriveGame

7 块区域

局部变量的生命周期范围只限于声明它的方法还呆在栈上的期间内，但有一种变量比局部变量生命周期更短，那就是在块区域{}内的块变量，例如for，while，if里的变量，使用块变量比使用局部变量更方便除错，且扩充性更好

6 链接的调用

StringBuffer sb = new StringBuffer(“spring”);
sb = sb.delete(3,6).insert(2,”umme”).deleteCharAt(1);
System.out.println(“sb = “ + sb);
// result is sb = summer
等同于：
sb = sb.delete(3,6);
sb = sb.insert(2,”umme”);
sb = sb.deleteCharAt(1);

5 Anonymous和Static Nested Classes

嵌套类(nested classes)和内部类(inner classes)的区别：任何一个被定义在另一个类范围内的类都称为嵌套类，不管它是匿名、静态、正常或其他类型。但非静态的嵌套类我们一般称之为内部类。所以基本上所有内部类都是嵌套类，但不是所有嵌套类都是内部类
静态嵌套类
静态嵌套很像一般非嵌套，他们没有与外层对象产生任何特殊关联。但因为还被认为是外层的一个成员，所以能够存取任何外层的私用成员，当然只限于是静态的，这是因为静态没有实例

public class FooOuter {
    static class BarInner {
        void sayIt() {
            System.out.println(“method of a static inner class”);
        }
    }
}

class Test {
    public static void main(String[] args) {
        FooOuter.BarInner foo = new FooOuter.BarInner();
        foo.sayIt();
    }
}

匿名内部类

import java.awt.event.*;
import javax.swing.*;
public class TestAnon {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        JButton button = new JButton(“click”);
        frame.getContentPane().add(button);
        // button.addActionListener(quitListener);
        //此处的ActionListener其实是一个接口，而我们不能创建接口的实例！但这种情况的语法就是这样
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent ev) {
                System.exit(0);
            }
        }) 
    }
}

4 存取权限和存取修饰符(谁可以看到什么)

public 代表任何代码都可以存取。一般用来修饰类、常量(static final variables)、对外方法(getter，setter)、大部分构造函数
private 代表只有同一类中的代码才能存取，它是对类而不是对对象设限。一般用来修饰大部分实例变量，以及不想被外部调用的方法
default 只有同一包中的默认事物才能存取。如果被default修饰(就是不修饰)就代表只有同一个包内的代码才能存取被修饰的事物，不能存取意味着你连用都不能用到相关的代码。如果一个类被default修饰，那么类中的方法即使是被public修饰，它也不能被包外的代码使用
protected 基本等同于default，只有一个地方不一样，被default修饰的事物允许包外的子类通过继承来获得它的功能。例如包外有一个子类有对父类的引用，父类里面有一个被protected修饰的方法，那子类是不能直接用父类的引用调用这个方法的，唯一的方法就是继承父类从而得到方法

3 String和StringBuilder的方法

常用的类是String和StringBuilder(因为String有不变性，使用StringBuilder操作String会更有效率，更省空间)
String和StringBuilder都有的方法：
char charAt(int index);//获取指定位置的字符
int length();
String substring(int start,int end);//取出指定片段的字符串
String toString();
连接字符串方法：
String concat(String str);//String的方法
String append(String str);//Stringbuilder的方法
String的方法：
String replace(char old,char new);//替换所有old字符为new字符
char[] toCharArray();
String toLowerCase();//全部小写
String toUpperCase();
String trim();//去除首尾空格
static String valueOf(char[] data);//转化为字符串
static String valueOf(int i);
StringBuilder的方法：
StringBuilder delete(int start,int end);
StringBuilder insert(int offset,String str);
StringBuilder replace(int start, int end, String str);
StringBuilder reverse();
void setCharAt (int index,char ch);

2 多维数组

在Java中如果你创建了一个4*2的数组，这个数组实际上由5个数组组成，例如
int[][] a =new int[][]{{1,2},{3,4},{5,6},{7,8}};
操作多维数组
存取第三个数组的第二个元素：int x = a[2][1];
对某个子数组创建引用：int[] copy = a[1];
初始化2*3数组：int[][] x = {{2,3,4},{5,6,7}};
创建非常规数组：int[][]y = new int[2][];
y[0] = new int[3];
y[1] = new int[5];

1 枚举(又称为枚举类型或Enum)

枚举是一种特殊的类，Enum的构造函数会对每个被声明的Enum值执行一次，每个Enum都有内置的values()方法，通常会用在for循环里

public class HfjEnum {
    enum Names {
        JERRY(“lead guitar”) {
            public String sings() {
                return“plaintively”;
            }
        },
        BOBBY(“rhythm guitar”) {
            public String sings() {
                return“hoarsely”;
            }
        },
        PHIL(“bass”);

        private String instrument;

        Names(String instrument) {
            this.instrument = instrument;
        }

        public String getInstrument() {
            return this.instrument;
        }

        public String sings() {
            return“occasionally”;
        }
    }

    public static void main(String[] args) {
        for (Names n : Names.values()) {
            System.out.print(n);
            System.out.print(“, instrument:“+n.getInstrument());
            System.out.println(“, sings:“+n.sings());
        }
    }
}

Head First Java 十大遗珠之憾