type erasure & reified generic
Java的泛型不同于C++的模板：Java泛型是"type erasure"，C++模板是"reified generic"。
- type erasure：泛型類型僅存在于編譯期間，編譯后的字節碼和運行時不包含泛型信息，所有的泛型類型映射到同一份字節碼。
- reified generic：泛型類型存在于編譯和運行期間，編譯器自動為每一種泛型類型生成類型代碼并編譯進二進制碼中。
為什么Java是type erasure
這是由于泛型是后來(SE5)才加入到Java語言特性的，Java讓編譯器擦除掉關于泛型類型的信息，這樣使得Java可以向后兼容之前沒有使用泛型的類庫和代碼，因為在字節碼層面是沒有泛型概念的。
type erasure的本質
泛型(T) --> 編譯器(type erasure) --> 原始類型(T被Object替換)
泛型(? extends XXX) --> 編譯器(type erasure) --> 原始類型(T被XXX替換)
原始類型指被編譯器擦除了泛型信息后，類型變量在字節碼中的具體類型。
假如，我們定義一個泛型類Generic是這樣的：
class Generic<T> {
private T obj;
public Generic(T o) {
obj = o;
}
public T getObj() {
return obj;
}
}
那么，Java編譯后的字節碼中Generic相當于這樣的：
class Generic {
private Object obj;
public Generic(Object o) {
obj = o;
}
public Object getObj() {
return obj;
}
}
假如，我們使用Generic類是這樣的：
public static void main(String[] args) {
Generic<String> generic = new Generic<String>("hehe...");
String str = generic.getObj();
}
那么，Java編譯后的字節碼中相當于這樣的：
public static void main(String[] args) {
Generic generic = new Generic("hehe...");
String str = (String) generic.getObj();
}
所以，所有Generic的泛型類型實質是同一個類：
public static void main(String[] args) {
Generic<Integer> a = new Generic<Integer>(111);
Generic<String> b = new Generic<String>("bbb");
System.out.println("a'class: " + a.getClass().getName());
System.out.println("b'class: " + b.getClass().getName());
System.out.println("G'class: " + Generic.class.getName());
System.out.println("a'class == b'class == G'class: " + (a.getClass() == b.getClass() && b.getClass() == Generic.class));
}
上述代碼執行結果：
a'class: generic.Generic
b'class: generic.Generic
G'class: generic.Generic
a'class == b'class == G'class: true
小結：Java的泛型只存在于編譯時期，泛型使編譯器可以在編譯期間對類型進行檢查以提高類型安全，減少運行時由于對象類型不匹配引發的異常。
type erasure導致泛型的局限性
類型擦除降低了泛型的泛化性，使得某些重要的上下文環境中不能使用泛型類型，具有一定的局限性。
運行時隱含類型轉換的開銷
使用泛型時，Java編譯器自動幫我們生成了類型轉換的代碼，這相對于C++模板來說無疑帶來了額外的性能開銷。
類型參數不能實例化
T obj = new T(); // compile error
T[] objs = new T[10]; // compile error
Generic<String> generic = new Generic<String>[10]; // compile error
類型參數不能進行類型查詢(類型查詢在運行時，運行時類型參數已被擦除)
Generic<Integer> a = new Generic<Integer>(111);
if(a instanceof Generic<String>)// compile error
if(a instanceof Generic<T>) // compile error
if(a instanceof Generic) // 僅測試了a是否是Generic，忽略了類型參數
不能在靜態域和靜態方法中引用類型變量
class Generic<T> {
private static T obj;// compile error
public static T func(){...}// compile error
}
因為所有泛型類最終映射到同一個原始類型類，而靜態屬性是類級別的，類和實例共同擁有它的一份存儲，因此一份存儲無法安放多個類型的屬性。靜態方法也是如此。
重載方法簽名沖突：
public boolean equals(T obj) // compile error
public boolean equals(T obj)被擦除類型后變為public boolean equals(Object obj)，與根類Object的public boolean equals(Object obj)簽名一樣，而兩者均不能覆蓋對方，導致編譯期名稱沖突。
一個類不能實現同一個泛型接口的兩種變體：
interface IFace<T>() {}
class FaceImpParent implements IFace<String> {}
class FaceImpChild extends FaceImpParent implements IFace<Integer> {} // compile error
原因是IFace<String>和IFace<Integer>在擦除類型后是同一個接口，一個類不能實現兩次同一個接口。
泛型類不能擴展java.lang.Throwable
class GenericException <T> extends Exception {} // compile error
