阅读The Java® Language Specification需要知道的术语

Null Pointer Exception，简称NPE

在java中，static final修饰的是常量。根据编译器的不同行为，常量又可分为编译时常量和运行时常量。

举例说明吧

public static final int a = 10就是一个编译时常量，在编译后的符号中找不到a，所有对a的引用都被替换成了20；它是不依赖于类的，在编译时就可以确定值。
public static final int b = “hello”.length()就是一个运行时常量；它是依赖于类的，它的赋值会引起类的初始化。
归根结底还是javac的编译机制导致了这样的结果。当涉及到方法的调用时，必须在运行的时候才能确定结果。

public class TestConstant {
    public static void main(String[] args) {
        System.out.println(Test.a);
        System.out.println(Test.s);
//      System.out.println(Test.b);
//      System.out.println(Test.a2);
//      System.out.println(Test.a3);
//      System.out.println(Test.e);
    }
}

class Test{
    static{
        System.out.println("Test正在被初始化");
    }
    public static final int a = 10;
    public static final int b = "test".length();
    public static final String s = "world";
    public static Integer a2 = 20;
    public static final A a3 = new A();
    public static final E e = E.A;
}
class A{

}
enum E{
    A,B,C,D,E,F,G
}

挨个运行main函数中的打印语句，我们会发现编译时常量不会引起类的初始化，而运行时常量会引起类的初始化。
通过运行我们还可以得出如下结论，编译时常量必须定义为基本类型或者String，而不可能是引用类型或者包装类、枚举。

一道面试题：编译时常量存在什么样的风险？

编译时常量，在使用时会被直接写成值，而不会再从原来的类中读取。这样就会导致问题的产生：如果A类定义了常量，B类使用了常量，并且都进行了编译。当A类的源码被改动了，常量的值发生了变化。我们对A类进行了重新编译，但是没有对B类进行重新编译；那么B类中用到的是原来A类中的常量值，即旧值。这就导致了风险的发生。　　

EQ 就是 EQUAL等于 eq
NE 就是 NOT EQUAL不等于 ne
GT 就是 GREATER THAN大于 gt　
LT 就是 LESS THAN小于 lt
GE 就是 GREATER THAN OR EQUAL 大于等于 ge
LE 就是 LESS THAN OR EQUAL 小于等于 le

an integral type

byte: -128 to 127

short: -32768 to 32767

int: -2147483648 to 2147483647

long: -9223372036854775808 to 9223372036854775807

char: 0 to 65535

finalizer

The class Object has a protected method called finalize; this method can be overridden by other classes. The particular definition of finalize that can be invoked for an object is called the finalizer of that object. Before the storage for an object is reclaimed by the garbage collector, the Java Virtual Machine will invoke the finalizer of that object.

参考：https://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.6

final与effectively final

局部内部类和匿名内部类访问的局部变量必须由final修饰，java8开始，可以不加final修饰符，由系统默认添加。java将这个功能称为：Effectively final 功能。

In a uni-catch clause, an exception parameter that is not declared final (implicitly or explicitly) is considered effectively final if it never occurs within its scope as the left-hand operand of an assignment operator (§15.26).

comb rule

Choosing to search a nested class's superclass hierarchy before than the lexically enclosing scope is called the "comb rule" (§15.12.1).

15.12.2.7. Inferring Type Arguments Based on Actual Arguments

U << V indicates that type U is convertible to type V by method invocation conversion (§5.3), and U >> V indicates that type V is convertible to type U by method invocation conversion.

例如interface A<T>{}中的T。class B<T extends InputStream>中的T都是a type variable

public class Test3<X> {

	// A extends Object和B extends Comparable为R1,R2,Object与Comparable为B1与B2。 List<? extends A>与B为F1,F2
	public <A extends Object, B extends Comparable,C extends X> void test(List<? extends A> x, B b) {

	}
}

如上解释了TypeBound: extends TypeVariable形式。方法test中的类型参数中C extends X中的X为Type Variable形式。

关于构造函数和方法的类型擦除，举个例子：

public class TestGenericErasure<T extends InputStream> {

	public <X extends Serializable&Comparable<T>>void test01(T t,X x){

	}

}

擦除后变为：

public class TestGenericErasure {

    public TestGenericErasure() {
        super();
    }

    public void test01(InputStream t, Serializable x) {
    }
}

可以看到方法中所有的type parameter全部被擦除。一般方法中的类型参数、返回类型与形式参数类型都会进行泛型擦除。　

下面来看理解这句话：

The erasure of a type variable (§4.4) is the erasure of its leftmost bound.

举个例子，如下：

public class Generic<T extends Object & Appendable & AutoCloseable> {

  T t;

  T method() throws Exception {
    t.close();
    char c='\u0000';
    t.append(c);
    return t;
  }

  public <T> T method2(T t) {
    return t;
  }  

}

那么T将全部替换为Object,最后泛型擦除后的结果如下：

public class Generic{

    public Test() {
        super();
    }
    Object t;

    Object method() throws Exception {
        ((AutoCloseable)t).close();  // 强制类型转换
        char c = '\u0000';
        ((Appendable)t).append(c);  // 强制类型转换
        return t;
    }

    public Object method2(Object t) {
        return t;
    }
}

a variable arity method与a fixed arity method

public class Test1 {

	public void m(Object ...x){
		System.out.println("a variable arity method");
	}

	public void m(Object x){
		System.out.println("a fixed arity method");
	}

	public static void main(String[] args) {
		new Test1().m(null); // 打印为a variable arity method
	}
}

if and only if 会被写为iff　　

Covariance, Invariance and Contravariance 概念解析

At heart, these terms describe how the subtype relation is affected by type transformations. That is, if A and B are types, f is a type transformation, and ≤ the subtype relation (i.e. A ≤ B means that A is a subtype of B), we have

f is covariant if A ≤ B implies that f(A) ≤ f(B)
f is contravariant if A ≤ B implies that f(B) ≤ f(A)
f is invariant if neither of the above holds

如某些泛型是invariant，因为String≤ Object，但是List<String>与List<Object>没有关系

数组是covariant，因为String≤Object，有String[]≤Object[]

某些泛型是contravariant，因为String << Object，有List<? super Object> << List<? super String>

class AA{
    public Integer[] aa(){
        return null;
    }

    public String[] aa(int a){
        return null;
    }

    public String[] bb(int a){
        return null;
    }
}

class BB extends AA{
    public String[] bb(){
        return null;
    }
}

有通配符的泛型是contravariant，因为String≤Number,有List<? super Number> ≤ List<? super String>

class Food{}
class Fruit extends Food{}

class Plate<T>{}

public class Test3 {

    public void test(){
        Plate<? extends Fruit> a = null;
        Plate<? extends Food>  b = null;
        b = a;

        Plate<? super Food> c = null;
        Plate<? super Fruit> d = null;
        d = c;
    }
}

参阅文章：

（1）http://stackoverflow.com/questions/8481301/covariance-invariance-and-contravariance-explained-in-plain-english/42239324#42239324

（2）http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html#FAQ201