十大遗珠之憾

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());
        }
    }
}