泛型概念的提出（爲什麼需要泛型）？
首先，我們看下下面這段簡短的代碼:
1 public class GenericTest {
2
3 public static void main(String[] args) {
4 List list = new ArrayList();
5 list.add("qqyumidi");
6 list.add("corn");
7 list.add(100);
8
9 for (int i = 0; i < list.size(); i++) {
10 String name = (String) list.get(i); // 1
11 System.out.println("name:" + name);
12 }
13 }
14 }
定義了一個List類型的集合，先向其中加入了兩個字符串類型的值，隨後加入一個Integer類型的值。這是完全允許的，因爲此時list默認的類型爲Object類型。在之後的循環中，由於忘記了之前在list中也加入了Integer類型的值或其他編碼原因，很容易出現類似於//1中的錯誤。因爲編譯階段正常，而運行時會出現“java.lang.ClassCastException”異常。因此，導致此類錯誤編碼過程中不易發現。
在如上的編碼過程中，我們發現主要存在兩個問題：
1.當我們將一個對象放入集合中，集合不會記住此對象的類型，當再次從集合中取出此對象時，改對象的編譯類型變成了Object類型，但其運行時類型任然爲其本身類型。
2.因此，//1處取出集合元素時需要人爲的強制類型轉化到具體的目標類型，且很容易出現“java.lang.ClassCastException”異常。
那麼有沒有什麼辦法可以使集合能夠記住集合內元素各類型，且能夠達到只要編譯時不出現問題，運行時就不會出現“java.lang.ClassCastException”異常呢？答案就是使用泛型。
二.什麼是泛型？
泛型，即“參數化類型”。一提到參數，最熟悉的就是定義方法時有形參，然後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢？顧名思義，就是將類型由原來的具體的類型參數化，類似於方法中的變量參數，此時類型也定義成參數形式（可以稱之爲類型形參），然後在使用/調用時傳入具體的類型（類型實參）。
看着好像有點複雜，首先我們看下上面那個例子採用泛型的寫法。
1 public class GenericTest {
2
3 public static void main(String[] args) {
4 /*
5 List list = new ArrayList();
6 list.add("qqyumidi");
7 list.add("corn");
8 list.add(100);
9 */
10
11 List<String> list = new ArrayList<String>();
12 list.add("qqyumidi");
13 list.add("corn");
14 //list.add(100); // 1 提示編譯錯誤
15
16 for (int i = 0; i < list.size(); i++) {
17 String name = list.get(i); // 2
18 System.out.println("name:" + name);
19 }
20 }
21 }
採用泛型寫法後，在//1處想加入一個Integer類型的對象時會出現編譯錯誤，通過List<String>，直接限定了list集合中只能含有String類型的元素，從而在//2處無須進行強制類型轉換，因爲此時，集合能夠記住元素的類型信息，編譯器已經能夠確認它是String類型了。
結合上面的泛型定義，我們知道在List<String>中，String是類型實參，也就是說，相應的List接口中肯定含有類型形參。且get()方法的返回結果也直接是此形參類型（也就是對應的傳入的類型實參）。下面就來看看List接口的的具體定義：
1 public interface List<E> extends Collection<E> {
2
3 int size();
4
5 boolean isEmpty();
6
7 boolean contains(Object o);
8
9 Iterator<E> iterator();
10
11 Object[] toArray();
12
13 <T> T[] toArray(T[] a);
14
15 boolean add(E e);
16
17 boolean remove(Object o);
18
19 boolean containsAll(Collection<?> c);
20
21 boolean addAll(Collection<? extends E> c);
22
23 boolean addAll(int index, Collection<? extends E> c);
24
25 boolean removeAll(Collection<?> c);
26
27 boolean retainAll(Collection<?> c);
28
29 void clear();
30
31 boolean equals(Object o);
32
33 int hashCode();
34
35 E get(int index);
36
37 E set(int index, E element);
38
39 void add(int index, E element);
40
41 E remove(int index);
42
43 int indexOf(Object o);
44
45 int lastIndexOf(Object o);
46
47 ListIterator<E> listIterator();
48
49 ListIterator<E> listIterator(int index);
50
51 List<E> subList(int fromIndex, int toIndex);
52 }
我們可以看到，在List接口中採用泛型化定義之後，<E>中的E表示類型形參，可以接收具體的類型實參，並且此接口定義中，凡是出現E的地方均表示相同的接受自外部的類型實參。
自然的，ArrayList作爲List接口的實現類，其定義形式是：
1 public class ArrayList<E> extends AbstractList<E>
2 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
3
4 public boolean add(E e) {
5 ensureCapacityInternal(size + 1); // Increments modCount!!
6 elementData[size++] = e;
7 return true;
8 }
9
10 public E get(int index) {
11 rangeCheck(index);
12 checkForComodification();
13 return ArrayList.this.elementData(offset + index);
14 }
15
16 //...省略掉其他具體的定義過程
17
18 }
由此，我們從源代碼角度明白了爲什麼//1處加入Integer類型對象編譯錯誤，且//2處get()到的類型直接就是String類型了。
三.自定義泛型接口、泛型類和泛型方法
從上面的內容中，大家已經明白了泛型的具體運作過程。也知道了接口、類和方法也都可以使用泛型去定義，以及相應的使用。是的，在具體使用時，可以分爲泛型接口、泛型類和泛型方法。
自定義泛型接口、泛型類和泛型方法與上述Java源碼中的List、ArrayList類似。如下，我們看一個最簡單的泛型類和方法定義：
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<String> name = new Box<String>("corn");
6 System.out.println("name:" + name.getData());
7 }
8
9 }
10
11 class Box<T> {
12
13 private T data;
14
15 public Box() {
16
17 }
18
19 public Box(T data) {
20 this.data = data;
21 }
22
23 public T getData() {
24 return data;
25 }
26
27 }
在泛型接口、泛型類和泛型方法的定義過程中，我們常見的如T、E、K、V等形式的參數常用於表示泛型形參，由於接收來自外部使用時候傳入的類型實參。那麼對於不同傳入的類型實參，生成的相應對象實例的類型是不是一樣的呢？
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<String> name = new Box<String>("corn");
6 Box<Integer> age = new Box<Integer>(712);
7
8 System.out.println("name class:" + name.getClass()); // com.qqyumidi.Box
9 System.out.println("age class:" + age.getClass()); // com.qqyumidi.Box
10 System.out.println(name.getClass() == age.getClass()); // true
11
12 }
13
14 }
由此，我們發現，在使用泛型類時，雖然傳入了不同的泛型實參，但並沒有真正意義上生成不同的類型，傳入不同泛型實參的泛型類在內存上只有一個，即還是原來的最基本的類型（本實例中爲Box），當然，在邏輯上我們可以理解成多個不同的泛型類型。
究其原因，在於Java中的泛型這一概念提出的目的，導致其只是作用於代碼編譯階段，在編譯過程中，對於正確檢驗泛型結果後，會將泛型的相關信息擦出，也就是說，成功編譯過後的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。
對此總結成一句話：泛型類型在邏輯上看以看成是多個不同的類型，實際上都是相同的基本類型。
四.類型通配符
接着上面的結論，我們知道，Box<Number>和Box<Integer>實際上都是Box類型，現在需要繼續探討一個問題，那麼在邏輯上，類似於Box<Number>和Box<Integer>是否可以看成具有父子關係的泛型類型呢？
爲了弄清這個問題，我們繼續看下下面這個例子:
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<Number> name = new Box<Number>(99);
6 Box<Integer> age = new Box<Integer>(712);
7
8 getData(name);
9
10 //The method getData(Box<Number>) in the type GenericTest is
11 //not applicable for the arguments (Box<Integer>)
12 getData(age); // 1
13
14 }
15
16 public static void getData(Box<Number> data){
17 System.out.println("data :" + data.getData());
18 }
19
20 }
我們發現，在代碼//1處出現了錯誤提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。顯然，通過提示信息，我們知道Box<Number>在邏輯上不能視爲Box<Integer>的父類。那麼，原因何在呢？
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<Integer> a = new Box<Integer>(712);
6 Box<Number> b = a; // 1
7 Box<Float> f = new Box<Float>(3.14f);
8 b.setData(f); // 2
9
10 }
11
12 public static void getData(Box<Number> data) {
13 System.out.println("data :" + data.getData());
14 }
15
16 }
17
18 class Box<T> {
19
20 private T data;
21
22 public Box() {
23
24 }
25
26 public Box(T data) {
27 setData(data);
28 }
29
30 public T getData() {
31 return data;
32 }
33
34 public void setData(T data) {
35 this.data = data;
36 }
37
38 }
這個例子中，顯然//1和//2處肯定會出現錯誤提示的。在此我們可以使用反證法來進行說明。
假設Box<Number>在邏輯上可以視爲Box<Integer>的父類，那麼//1和//2處將不會有錯誤提示了，那麼問題就出來了，通過getData()方法取出數據時到底是什麼類型呢？Integer? Float? 還是Number？且由於在編程過程中的順序不可控性，導致在必要的時候必須要進行類型判斷，且進行強制類型轉換。顯然，這與泛型的理念矛盾，因此，在邏輯上Box<Number>不能視爲Box<Integer>的父類。
好，那我們回過頭來繼續看“類型通配符”中的第一個例子，我們知道其具體的錯誤提示的深層次原因了。那麼如何解決呢？總部能再定義一個新的函數吧。這和Java中的多態理念顯然是違背的，因此，我們需要一個在邏輯上可以用來表示同時是Box<Integer>和Box<Number>的父類的一個引用類型，由此，類型通配符應運而生。
類型通配符一般是使用 ? 代替具體的類型實參。注意了，此處是類型實參，而不是類型形參！且Box<?>在邏輯上是Box<Integer>、Box<Number>...等所有Box<具體類型實參>的父類。由此，我們依然可以定義泛型方法，來完成此類需求。
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<String> name = new Box<String>("corn");
6 Box<Integer> age = new Box<Integer>(712);
7 Box<Number> number = new Box<Number>(314);
8
9 getData(name);
10 getData(age);
11 getData(number);
12 }
13
14 public static void getData(Box<?> data) {
15 System.out.println("data :" + data.getData());
16 }
17
18 }
有時候，我們還可能聽到類型通配符上限和類型通配符下限。具體有是怎麼樣的呢？
在上面的例子中，如果需要定義一個功能類似於getData()的方法，但對類型實參又有進一步的限制：只能是Number類及其子類。此時，需要用到類型通配符上限。
1 public class GenericTest {
2
3 public static void main(String[] args) {
4
5 Box<String> name = new Box<String>("corn");
6 Box<Integer> age = new Box<Integer>(712);
7 Box<Number> number = new Box<Number>(314);
8
9 getData(name);
10 getData(age);
11 getData(number);
12
13 //getUpperNumberData(name); // 1
14 getUpperNumberData(age); // 2
15 getUpperNumberData(number); // 3
16 }
17
18 public static void getData(Box<?> data) {
19 System.out.println("data :" + data.getData());
20 }
21
22 public static void getUpperNumberData(Box<? extends Number> data){
23 System.out.println("data :" + data.getData());
24 }
25
26 }
此時，顯然，在代碼//1處調用將出現錯誤提示，而//2 //3處調用正常。
類型通配符上限通過形如Box<? extends Number>形式定義，相對應的，類型通配符下限爲Box<? super Number>形式，其含義與類型通配符上限正好相反，在此不作過多闡述了。
五.話外篇
本文中的例子主要是爲了闡述泛型中的一些思想而簡單舉出的，並不一定有着實際的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其實，在實際的編程過程中，自己可以使用泛型去簡化開發，且能很好的保證代碼質量。並且還要注意的一點是，Java中沒有所謂的泛型數組一說。
對於泛型，最主要的還是需要理解其背後的思想和目的。
類型擦除引起的問題及解決方法
因爲種種原因，Java不能實現真正的泛型，只能使用類型擦除來實現僞泛型，這樣雖然不會有類型膨脹的問題，但是也引起了許多新的問題。所以，Sun對這些問題作出了許多限制，避免我們犯各種錯誤。
1、先檢查，在編譯，以及檢查編譯的對象和引用傳遞的問題
既然說類型變量會在編譯的時候擦除掉，那爲什麼我們往ArrayList<String> arrayList=new ArrayList<String>();所創建的數組列表arrayList中，不能使用add方法添加整形呢？不是說泛型變量Integer會在編譯時候擦除變爲原始類型Object嗎，爲什麼不能存別的類型呢？既然類型擦除了，如何保證我們只能使用泛型變量限定的類型呢？
java是如何解決這個問題的呢？java編譯器是通過先檢查代碼中泛型的類型，然後再進行類型擦除，在進行編譯的。舉個例子說明：
- public static void main(String[] args) {
- ArrayList<String> arrayList=new ArrayList<String>();
- arrayList.add("123");
- arrayList.add(123);//編譯錯誤
- }
那麼，這麼類型檢查是針對誰的呢？我們先看看參數化類型與原始類型的兼容
- ArrayList arrayList=new ArrayList();
- ArrayList<String> arrayList=new ArrayList<String>();
如果是與以前的代碼兼容，各種引用傳值之間，必然會出現如下的情況：
- ArrayList<String> arrayList1=new ArrayList(); //第一種 情況
- ArrayList arrayList2=new ArrayList<String>();//第二種 情況
這樣是沒有錯誤的，不過會有個編譯時警告。
不過在第一種情況，可以實現與 完全使用泛型參數一樣的效果，第二種則完全沒效果。
因爲，本來類型檢查就是編譯時完成的。new ArrayList()只是在內存中開闢一個存儲空間，可以存儲任何的類型對象。而真正涉及類型檢查的是它的引用，因爲我們是使用它引用arrayList1 來調用它的方法，比如說調用add()方法。所以arrayList1引用能完成泛型類型的檢查。
而引用arrayList2沒有使用泛型，所以不行。
舉例子：
- public class Test10 {
- public static void main(String[] args) {
- //
- ArrayList<String> arrayList1=new ArrayList();
- arrayList1.add("1");//編譯通過
- arrayList1.add(1);//編譯錯誤
- String str1=arrayList1.get(0);//返回類型就是String
- ArrayList arrayList2=new ArrayList<String>();
- arrayList2.add("1");//編譯通過
- arrayList2.add(1);//編譯通過
- Object object=arrayList2.get(0);//返回類型就是Object
- new ArrayList<String>().add("11");//編譯通過
- new ArrayList<String>().add(22);//編譯錯誤
- String string=new ArrayList<String>().get(0);//返回類型就是String
- }
- }
通過上面的例子，我們可以明白，類型檢查就是針對引用的，誰是一個引用，用這個引用調用泛型方法，就會對這個引用調用的方法進行類型檢測，而無關它真正引用的對象。
從這裏，我們可以再討論下 泛型中參數化類型爲什麼不考慮繼承關係
在Java中，像下面形式的引用傳遞是不允許的：
- ArrayList<String> arrayList1=new ArrayList<Object>();//編譯錯誤
- ArrayList<Object> arrayList1=new ArrayList<String>();//編譯錯誤
我們先看第一種情況，將第一種情況拓展成下面的形式：
- ArrayList<Object> arrayList1=new ArrayList<Object>();
- arrayList1.add(new Object());
- arrayList1.add(new Object());
- ArrayList<String> arrayList2=arrayList1;//編譯錯誤
在看第二種情況，將第二種情況拓展成下面的形式：
- ArrayList<String> arrayList1=new ArrayList<String>();
- arrayList1.add(new String());
- arrayList1.add(new String());
- ArrayList<Object> arrayList2=arrayList1;//編譯錯誤
所以，要格外注意，泛型中的引用傳遞的問題。
2、自動類型轉換
因爲類型擦除的問題，所以所有的泛型類型變量最後都會被替換爲原始類型。這樣就引起了一個問題，既然都被替換爲原始類型，那麼爲什麼我們在獲取的時候，不需要進行強制類型轉換呢？看下ArrayList和get方法：
- public E get(int index) {
- RangeCheck(index);
- return (E) elementData[index];
- }
看以看到，在return之前，會根據泛型變量進行強轉。
寫了個簡單的測試代碼：
- public class Test {
- public static void main(String[] args) {
- ArrayList<Date> list=new ArrayList<Date>();
- list.add(new Date());
- Date myDate=list.get(0);
- }
然後反編了下字節碼，如下
- public static void main(java.lang.String[]);
- Code:
- 0: new #16 // class java/util/ArrayList
- 3: dup
- 4: invokespecial #18 // Method java/util/ArrayList."<init
- :()V
- 7: astore_1
- 8: aload_1
- 9: new #19 // class java/util/Date
- 12: dup
- 13: invokespecial #21 // Method java/util/Date."<init>":()
- 16: invokevirtual #22 // Method java/util/ArrayList.add:(L
- va/lang/Object;)Z
- 19: pop
- 20: aload_1
- 21: iconst_0
- 22: invokevirtual #26 // Method java/util/ArrayList.get:(I
- java/lang/Object;
- 25: checkcast #19 // class java/util/Date
- 28: astore_2
- 29: return
看第22 ，它調用的是ArrayList.get()方法，方法返回值是Object，說明類型擦除了。然後第25，它做了一個checkcast操作，即檢查類型#19， 在在上面找#19引用的類型，他是
9: new #19 // class java/util/Date
是一個Date類型，即做Date類型的強轉。
所以不是在get方法裏強轉的，是在你調用的地方強轉的。
附關於checkcast的解釋：
checkcast checks that the top item on the operand stack (a reference to an object or array) can be cast to a given type. For example, if you write in Java:
return ((String)obj);
then the Java compiler will generate something like:
aload_1 ; push -obj- onto the stack
checkcast java/lang/String ; check its a String
areturn ; return it
checkcast is actually a shortand for writing Java code like:
if (! (obj == null || obj instanceof <class>)) {
throw new ClassCastException();
}
// if this point is reached, then object is either null, or an instance of
// <class> or one of its superclasses.
3、類型擦除與多態的衝突和解決方法
現在有這樣一個泛型類：
- class Pair<T> {
- private T value;
- public T getValue() {
- return value;
- }
- public void setValue(T value) {
- this.value = value;
- }
- }
然後我們想要一個子類繼承它
- class DateInter extends Pair<Date> {
- @Override
- public void setValue(Date value) {
- super.setValue(value);
- }
- @Override
- public Date getValue() {
- return super.getValue();
- }
- }
將父類的泛型類型限定爲Date，那麼父類裏面的兩個方法的參數都爲Date類型：“
- public Date getValue() {
- return value;
- }
- public void setValue(Date value) {
- this.value = value;
- }
所以，我們在子類中重寫這兩個方法一點問題也沒有，實際上，從他們的@Override標籤中也可以看到，一點問題也沒有，實際上是這樣的嗎？
分析：
實際上，類型擦除後，父類的的泛型類型全部變爲了原始類型Object，所以父類編譯之後會變成下面的樣子：
- class Pair {
- private Object value;
- public Object getValue() {
- return value;
- }
- public void setValue(Object value) {
- this.value = value;
- }
- }
- @Override
- public void setValue(Date value) {
- super.setValue(value);
- }
- @Override
- public Date getValue() {
- return super.getValue();
- }
我們在一個main方法測試一下：
- public static void main(String[] args) throws ClassNotFoundException {
- DateInter dateInter=new DateInter();
- dateInter.setValue(new Date());
- dateInter.setValue(new Object());//編譯錯誤
- }
爲什麼會這樣呢？
原因是這樣的，我們傳入父類的泛型類型是Date，Pair<Date>，我們的本意是將泛型類變爲如下：
- class Pair {
- private Date value;
- public Date getValue() {
- return value;
- }
- public void setValue(Date value) {
- this.value = value;
- }
- }
可是由於種種原因，虛擬機並不能將泛型類型變爲Date，只能將類型擦除掉，變爲原始類型Object。這樣，我們的本意是進行重寫，實現多態。可是類型擦除後，只能變爲了重載。這樣，類型擦除就和多態有了衝突。JVM知道你的本意嗎？知道！！！可是它能直接實現嗎，不能！！！如果真的不能的話，那我們怎麼去重寫我們想要的Date類型參數的方法啊。
於是JVM採用了一個特殊的方法，來完成這項功能，那就是橋方法。
首先，我們用javap -c className的方式反編譯下DateInter子類的字節碼，結果如下：
- class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
- com.tao.test.DateInter();
- Code:
- 0: aload_0
- 1: invokespecial #8 // Method com/tao/test/Pair."<init>"
- :()V
- 4: return
- public void setValue(java.util.Date); //我們重寫的setValue方法
- Code:
- 0: aload_0
- 1: aload_1
- 2: invokespecial #16 // Method com/tao/test/Pair.setValue
- :(Ljava/lang/Object;)V
- 5: return
- public java.util.Date getValue(); //我們重寫的getValue方法
- Code:
- 0: aload_0
- 1: invokespecial #23 // Method com/tao/test/Pair.getValue
- :()Ljava/lang/Object;
- 4: checkcast #26 // class java/util/Date
- 7: areturn
- public java.lang.Object getValue(); //編譯時由編譯器生成的巧方法
- Code:
- 0: aload_0
- 1: invokevirtual #28 // Method getValue:()Ljava/util/Date 去調用我們重寫的getValue方法
- ;
- 4: areturn
- public void setValue(java.lang.Object); //編譯時由編譯器生成的巧方法
- Code:
- 0: aload_0
- 1: aload_1
- 2: checkcast #26 // class java/util/Date
- 5: invokevirtual #30 // Method setValue:(Ljava/util/Date; 去調用我們重寫的setValue方法
- )V
- 8: return
- }
所以，虛擬機巧妙的使用了巧方法，來解決了類型擦除和多態的衝突。
不過，要提到一點，這裏面的setValue和getValue這兩個橋方法的意義又有不同。
setValue方法是爲了解決類型擦除與多態之間的衝突。
而getValue卻有普遍的意義，怎麼說呢，如果這是一個普通的繼承關係：
那麼父類的setValue方法如下：
- public ObjectgetValue() {
- return super.getValue();
- }
- public Date getValue() {
- return super.getValue();
- }
關於協變：。。。。。。
並且，還有一點也許會有疑問，子類中的巧方法 Object getValue()和Date getValue()是同 時存在的，可是如果是常規的兩個方法，他們的方法簽名是一樣的，也就是說虛擬機根本不能分別這兩個方法。如果是我們自己編寫Java代碼，這樣的代碼是無法通過編譯器的檢查的，但是虛擬機卻是允許這樣做的，因爲虛擬機通過參數類型和返回類型來確定一個方法，所以編譯器爲了實現泛型的多態允許自己做這個看起來“不合法”的事情，然後交給虛擬器去區別。
4、泛型類型變量不能是基本數據類型
不能用類型參數替換基本類型。就比如，沒有ArrayList<double>，只有ArrayList<Double>。因爲當類型擦除後，ArrayList的原始類型變爲Object，但是Object類型不能存儲double值，只能引用Double的值。
5、運行時類型查詢
舉個例子:
- ArrayList<String> arrayList=new ArrayList<String>();
因爲類型擦除之後，ArrayList<String>只剩下原始類型，泛型信息String不存在了。
那麼，運行時進行類型查詢的時候使用下面的方法是錯誤的
- if( arrayList instanceof ArrayList<?>)
？ 是通配符的形式 ，將在後面一篇中介紹。
6、異常中使用泛型的問題
1、不能拋出也不能捕獲泛型類的對象。事實上，泛型類擴展Throwable都不合法。例如：下面的定義將不會通過編譯：
- public class Problem<T> extends Exception{......}
- try{
- }catch(Problem<Integer> e1){
- 。。
- }catch(Problem<Number> e2){
- ...
- }
- try{
- }catch(Problem<Object> e1){
- 。。
- }catch(Problem<Object> e2){
- ...
- try{
- }catch(Exception e1){
- 。。
- }catch(Exception e2){//編譯錯誤
- ...
2、不能再catch子句中使用泛型變量
- public static <T extends Throwable> void doWork(Class<T> t){
- try{
- ...
- }catch(T e){ //編譯錯誤
- ...
- }
- }
- public static <T extends Throwable> void doWork(Class<T> t){
- try{
- ...
- }catch(T e){ //編譯錯誤
- ...
- }catch(IndexOutOfBounds e){
- }
- }
但是在異常聲明中可以使用類型變量。下面方法是合法的。
- public static<T extends Throwable> void doWork(T t) throws T{
- try{
- ...
- }catch(Throwable realCause){
- t.initCause(realCause);
- throw t;
- }
7、數組（這個不屬於類型擦除引起的問題）
不能聲明參數化類型的數組。如：
- Pair<String>[] table = newPair<String>(10); //ERROR
- Object[] objarray =table;
- objarray ="Hello"; //ERROR
- objarray =new Pair<Employee>();
8、泛型類型的實例化
不能實例化泛型類型。如，
- first = new T(); //ERROR
不能建立一個泛型數組。
- public<T> T[] minMax(T[] a){
- T[] mm = new T[2]; //ERROR
- ...
- }
類似的，擦除會使這個方法總是構靠一個Object[2]數組。但是，可以用反射構造泛型對象和數組。
利用反射，調用Array.newInstance:
- publicstatic <T extends Comparable> T[]minmax(T[] a)
- {
- T[] mm == (T[])Array.newInstance(a.getClass().getComponentType(),2);
- ...
- // 以替換掉以下代碼
- // Obeject[] mm = new Object[2];
- // return (T[]) mm;
- }
1、
- class Pair<T> {
- public boolean equals(T value) {
- return null;
- }
- }
booleanequals(String); //在Pair<T>中定義
boolean equals(Object); //從object中繼承
但是，這只是一種錯覺。實際上，擦除後方法
boolean equals(T)
變成了方法 boolean equals(Object)
這與Object.equals方法是衝突的！當然，補救的辦法是重新命名引發錯誤的方法。
2、
泛型規範說明提及另一個原則“要支持擦除的轉換，需要強行制一個類或者類型變量不能同時成爲兩個接口的子類，而這兩個子類是同一接品的不同參數化。”
下面的代碼是非法的：
- class Calendar implements Comparable<Calendar>{ ... }
- class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...} //ERROR
這一限制與類型擦除的關係並不很明確。非泛型版本：
- class Calendar implements Comparable{ ... }
- class GregorianCalendar extends Calendar implements Comparable{...} //ERROR
10、泛型在靜態方法和靜態類中的問題
泛型類中的靜態方法和靜態變量不可以使用泛型類所聲明的泛型類型參數
舉例說明：
但是要注意區分下面的一種情況：
轉：http://www.cnblogs.com/lwbqqyumidi/p/3837629.html#undefined