泛型之前
在面向對象程式設計語言中，多态算是一種泛化機制。例如，你可以将方法的參數類型設定為基類，那麼該方法就可以接受從這個基類中導出的任何類作為參數，這樣的方法将會更具有通用性。此外，如果将方法參數聲明為接口，将會更加靈活。
在Java增加泛型類型之前，通用程式的設計就是利用繼承實作的，例如，ArrayList類隻維護一個Object引用的數組，Object為所有類基類。
[java] view plain copy
public class BeforeGeneric {
static class ArrayList{//泛型之前的通用程式設計
private Object[] elements=new Object[0];
public Object get(int i){
return elements[i];
}
public void add(Object o){
//這裡的實作，隻是為了示範，不具有任何參考價值
int length=elements.length;
Object[] newElments=new Object[length+1];
for(int i=0;i<length;i++){
newElments[i]=elements[i];
}
newElments[length]=o;
elements=newElments;
}
public static void main(String[] args) {
ArrayList stringValues=new ArrayList();
stringValues.add(1);//可以向數組中添加任何類型的對象
//問題1——擷取值時必須強制轉換
String str=(String) stringValues.get(0);
//問題2——上述強制轉型編譯時不會出錯，而運作時報異常java.lang.ClassCastException
}
這樣的實作面臨兩個問題：
1、當我們擷取一個值的時候，必須進行強制類型轉換。
2、假定我們預想的是利用stringValues來存放String集合，因為ArrayList隻是維護一個Object引用的數組，我們無法阻止将Integer類型（Object子類）的資料加入stringValues。然而，當我們使用資料的時候，需要将擷取的Object對象轉換為我們期望的類型（String），如果向集合中添加了非預期的類型（如Integer），編譯時我們不會收到任何的錯誤提示。但當我們運作程式時卻會報異常：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at generic.BeforeGeneric.main(BeforeGeneric.java:24)
這顯然不是我們所期望的，如果程式有潛在的錯誤，我們更期望在編譯時被告知錯誤，而不是在運作時報異常。
泛型
針對利用繼承來實作通用程式設計所産生的問題，泛型提供了更好的解決方案：類型參數。例如，ArrayList類用一個類型參數來指出元素的類型。
ArrayList<String> stringValues=new ArrayList<String>();
這樣的代碼具有更好的可讀性，我們一看就知道該集合用來儲存String類型的對象，而不是僅僅依賴變量名稱來暗示我們期望的類型。
public class GenericType {
public static void main(String[] args) {
ArrayList<String> stringValues=new ArrayList<String>();
stringValues.add("str");
stringValues.add(1); //編譯錯誤
}
現在，如果我們向ArrayList<String>添加Integer類型的對象，将會出現編譯錯誤。
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)
at generic.GenericType.main(GenericType.java:8)
編譯器會自動幫我們檢查，避免向集合中插入錯誤類型的對象，進而使得程式具有更好的安全性。
總之，泛型通過類型參數使得我們的程式具有更好的可讀性和安全性。
Java泛型的實作原理
擦除
ArrayList<String> arrayString=new ArrayList<String>();
ArrayList<Integer> arrayInteger=new ArrayList<Integer>();
System.out.println(arrayString.getClass()==arrayInteger.getClass());
}
輸出：
true
在這個例子中，我們定義了兩個ArrayList數組，不過一個是ArrayList<String>泛型類型，隻能存儲字元串。一個是ArrayList<Integer>泛型類型，隻能存儲整型。最後，我們通過arrayString對象和arrayInteger對象的getClass方法擷取它們的類資訊并比較，發現結果為true。
這是為什麼呢，明明我們定義了兩種不同的類型？因為，在編譯期間，所有的泛型資訊都會被擦除，List<Integer>和List<String>類型，在編譯後都會變成List類型（原始類型）。Java中的泛型基本上都是在編譯器這個層次來實作的，這也是Java的泛型被稱為“僞泛型”的原因。
原始類型
原始類型就是泛型類型擦除了泛型資訊後，在位元組碼中真正的類型。無論何時定義一個泛型類型，相應的原始類型都會被自動提供。原始類型的名字就是删去類型參數後的泛型類型的類名。擦除類型變量，并替換為限定類型（T為無限定的類型變量，用Object替換）。
//泛型類型
class Pair<T> {
private T value;
public T getValue() {
return value;
public void setValue(T value) {
this.value = value;
//原始類型
class Pair {
private Object value;
public Object getValue() {
public void setValue(Object value) {
}
因為在Pair<T>中，T是一個無限定的類型變量，是以用Object替換。如果是Pair<T extends Number>，擦除後，類型變量用Number類型替換。
public class ReflectInGeneric {
public static void main(String[] args) throws IllegalArgumentException,
SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
ArrayList<Integer> array=new ArrayList<Integer>();
array.add(1);//這樣調用add方法隻能存儲整形，因為泛型類型的執行個體為Integer
array.getClass().getMethod("add", Object.class).invoke(array, "asd");
for (int i=0;i<array.size();i++) {
System.out.println(array.get(i));
}
1
asd
為什麼呢？我們在介紹泛型時指出向ArrayList<Integer>中插入String類型的對象，編譯時會報錯。現在為什麼又可以了呢？
我們在程式中定義了一個ArrayList<Integer>泛型類型，如果直接調用add方法，那麼隻能存儲整形的資料。不過當我們利用反射調用add方法的時候，卻可以存儲字元串。這說明ArrayList<Integer>泛型資訊在編譯之後被擦除了，隻保留了原始類型，類型變量（T）被替換為Object，在運作時，我們可以行其中插入任意類型的對象。
但是，并不推薦以這種方式操作泛型類型，因為這違背了泛型的初衷（減少強制類型轉換以及確定類型安全）。當我們從集合中擷取元素時，預設會将對象強制轉換成泛型參數指定的類型（這裡是Integer），如果放入了非法的對象這個強制轉換過程就會出現異常。
泛型方法的類型推斷
在調用泛型方法的時候，可以指定泛型類型，也可以不指定。
在不指定泛型類型的情況下，泛型類型為該方法中的幾種參數類型的共同父類的最小級，直到Object。
在指定泛型類型的時候，該方法中的所有參數類型必須是該泛型類型或者其子類。
public class Test {
/**不指定泛型的時候*/
int i=Test.add(1, 2); //這兩個參數都是Integer，是以T替換為Integer類型
Number f=Test.add(1, 1.2);//這兩個參數一個是Integer，另一個是Float，是以取同一父類的最小級，為Number
Object o=Test.add(1, "asd");//這兩個參數一個是Integer，另一個是String，是以取同一父類的最小級，為Object
/**指定泛型的時候*/
int a=Test.<Integer>add(1, 2);//指定了Integer，是以隻能為Integer類型或者其子類
int b=Test.<Integer>add(1, 2.2);//編譯錯誤，指定了Integer，不能為Float
Number c=Test.<Number>add(1, 2.2); //指定為Number，是以可以為Integer和Float
//這是一個簡單的泛型方法
public static <T> T add(T x,T y){
return y;
正确的運轉
既然說類型變量會在編譯的時候擦除掉，那為什麼定義了ArrayList<Integer>泛型類型，而不允許向其中插入String對象呢？不是說泛型變量Integer會在編譯時候擦除變為原始類型Object嗎，為什麼不能存放别的類型呢？既然類型擦除了，如何保證我們隻能使用泛型變量限定的類型呢？
java是如何解決這個問題的呢？java編譯器是通過先檢查代碼中泛型的類型，然後再進行類型擦除，再進行編譯的。以如下代碼為例：
Pair<Integer> pair=new Pair<Integer> ();
pair.setValue(3);
Integer integer=pair.getValue();
System.out.println(integer);
擦除getValue()的傳回類型後将傳回Object類型，編譯器自動插入Integer的強制類型轉換。也就是說，編譯器把這個方法調用翻譯為兩條位元組碼指令：
1、對原始方法Pair.getValue的調用
2、将傳回的Object類型強制轉換為Integer
此外，存取一個泛型域時，也要插入強制類型轉換。是以，我們說Java的泛型是在編譯器層次進行實作的，被稱為“僞泛型”，相對于C++。
泛型相關問題
1、泛型類型引用傳遞問題
在Java中，像下面形式的引用傳遞是不允許的：
ArrayList<String> arrayList1=new ArrayList<Object>();//編譯錯誤
ArrayList<Object> arrayList1=new ArrayList<String>();//編譯錯誤
我們先看第一種情況，将第一種情況拓展成下面的形式：
ArrayList<Object> arrayList1=new ArrayList<Object>();
arrayList1.add(new Object());
ArrayList<String> arrayList2=arrayList1;//編譯錯誤
實際上，在第4行代碼處，就會有編譯錯誤。那麼，我們先假設它編譯沒錯。那麼當我們使用arrayList2引用用get()方法取值的時候，傳回的都是String類型的對象，可是它裡面實際上已經被我們存放了Object類型的對象，這樣，就會有ClassCastException了。是以為了避免這種極易出現的錯誤，Java不允許進行這樣的引用傳遞。（這也是泛型出現的原因，就是為了解決類型轉換的問題，我們不能違背它的初衷）。
在看第二種情況，将第二種情況拓展成下面的形式：
ArrayList<String> arrayList1=new ArrayList<String>();
arrayList1.add(new String());
ArrayList<Object> arrayList2=arrayList1;//編譯錯誤
沒錯，這樣的情況比第一種情況好的多，最起碼，在我們用arrayList2取值的時候不會出現ClassCastException，因為是從String轉換為Object。可是，這樣做有什麼意義呢，泛型出現的原因，就是為了解決類型轉換的問題。我們使用了泛型，到頭來，還是要自己強轉，違背了泛型設計的初衷。是以java不允許這麼幹。再說，你如果又用arrayList2往裡面add()新的對象，那麼到時候取得時候，我怎麼知道我取出來的到底是String類型的，還是Object類型的呢？
是以，要格外注意泛型中引用傳遞問題。
2、泛型類型變量不能是基本資料類型
就比如，沒有ArrayList<double>，隻有ArrayList<Double>。因為當類型擦除後，ArrayList的原始類中的類型變量（T）替換為Object，但Object類型不能存儲double值。
3、運作時類型查詢
舉個例子:
ArrayList<String> arrayList=new ArrayList<String>();
因為類型擦除之後，ArrayList<String>隻剩下原始類型，泛型資訊String不存在了。那麼，運作時進行類型查詢的時候使用下面的方法是錯誤的
if( arrayList instanceof ArrayList<String>)
java限定了這種類型查詢的方式，？為通配符，也即非限定符。
if( arrayList instanceof ArrayList<?>)
4、泛型在靜态方法和靜态類中的問題
泛型類中的靜态方法和靜态變量不可以使用泛型類所聲明的泛型類型參數
public class Test2<T> {
public static T one; //編譯錯誤
public static T show(T one){ //編譯錯誤
return null;
}
因為泛型類中的泛型參數的執行個體化是在定義泛型類型對象（例如ArrayList<Integer>）的時候指定的，而靜态變量和靜态方法不需要使用對象來調用。對象都沒有建立，如何确定這個泛型參數是何種類型，是以當然是錯誤的。
但是要注意區分下面的一種情況：
public static <T >T show(T one){//這是正确的
因為這是一個泛型方法，在泛型方法中使用的T是自己在方法中定義的T，而不是泛型類中的T。
泛型相關面試題
1. Java中的泛型是什麼 ? 使用泛型的好處是什麼?
泛型是一種參數化類型的機制。它可以使得代碼适用于各種類型，進而編寫更加通用的代碼，例如集合架構。
泛型是一種編譯時類型确認機制。它提供了編譯期的類型安全，確定在泛型類型（通常為泛型集合）上隻能使用正确類型的對象，避免了在運作時出現ClassCastException。
2、Java的泛型是如何工作的 ? 什麼是類型擦除 ?
泛型的正常工作是依賴編譯器在編譯源碼的時候，先進行類型檢查，然後進行類型擦除并且在類型參數出現的地方插入強制轉換的相關指令實作的。
編譯器在編譯時擦除了所有類型相關的資訊，是以在運作時不存在任何類型相關的資訊。例如List<String>在運作時僅用一個List類型來表示。為什麼要進行擦除呢？這是為了避免類型膨脹。
3. 什麼是泛型中的限定通配符和非限定通配符 ?
限定通配符對類型進行了限制。有兩種限定通配符，一種是<? extends T>它通過確定類型必須是T的子類來設定類型的上界，另一種是<? super T>它通過確定類型必須是T的父類來設定類型的下界。泛型類型必須用限定内的類型來進行初始化，否則會導緻編譯錯誤。另一方面<?>表示了非限定通配符，因為<?>可以用任意類型來替代。
4. List<? extends T>和List <? super T>之間有什麼差別 ?
這和上一個面試題有聯系，有時面試官會用這個問題來評估你對泛型的了解，而不是直接問你什麼是限定通配符和非限定通配符。這兩個List的聲明都是限定通配符的例子，List<? extends T>可以接受任何繼承自T的類型的List，而List<? super T>可以接受任何T的父類構成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。在本段出現的連接配接中可以找到更多資訊。
5. 如何編寫一個泛型方法，讓它能接受泛型參數并傳回泛型類型?
編寫泛型方法并不困難，你需要用泛型類型來替代原始類型，比如使用T, E or K,V等被廣泛認可的類型占位符。泛型方法的例子請參閱Java集合類架構。最簡單的情況下，一個泛型方法可能會像這樣:
public V put(K key, V value) {
return cache.put(key, value);
6. Java中如何使用泛型編寫帶有參數的類?
這是上一道面試題的延伸。面試官可能會要求你用泛型編寫一個類型安全的類，而不是編寫一個泛型方法。關鍵仍然是使用泛型類型來代替原始類型，而且要使用JDK中采用的标準占位符。
7. 編寫一段泛型程式來實作LRU緩存?
對于喜歡Java程式設計的人來說這相當于是一次練習。給你個提示，LinkedHashMap可以用來實作固定大小的LRU緩存，當LRU緩存已經滿了的時候，它會把最老的鍵值對移出緩存。LinkedHashMap提供了一個稱為removeEldestEntry()的方法，該方法會被put()和putAll()調用來删除最老的鍵值對。
8. 你可以把List<String>傳遞給一個接受List<Object>參數的方法嗎？
對任何一個不太熟悉泛型的人來說，這個Java泛型題目看起來令人疑惑，因為乍看起來String是一種Object，是以List<String>應當可以用在需要List<Object>的地方，但是事實并非如此。真這樣做的話會導緻編譯錯誤。如果你再深一步考慮，你會發現Java這樣做是有意義的，因為List<Object>可以存儲任何類型的對象包括String, Integer等等，而List<String>卻隻能用來存儲Strings。
List<Object> objectList;
List<String> stringList;
objectList = stringList; //compilation error incompatible types
9. Array中可以用泛型嗎?
這可能是Java泛型面試題中最簡單的一個了，當然前提是你要知道Array事實上并不支援泛型，這也是為什麼Joshua Bloch在Effective Java一書中建議使用List來代替Array，因為List可以提供編譯期的類型安全保證，而Array卻不能。
10. 如何阻止Java中的類型未檢查的警告?
如果你把泛型和原始類型混合起來使用，例如下列代碼，Java 5的javac編譯器會産生類型未檢查的警告
，例如List<String> rawList = new ArrayList()
注意: Hello.java使用了未檢查或稱為不安全的操作;
這種警告可以使用@SuppressWarnings("unchecked")注解來屏蔽。
11、Java中List<Object>和原始類型List之間的差別?
原始類型和帶參數類型<Object>之間的主要差別是，在編譯時編譯器不會對原始類型進行類型安全檢查，卻會對帶參數的類型進行檢查，通過使用Object作為類型，可以告知編譯器該方法可以接受任何類型的對象，比如String或Integer。這道題的考察點在于對泛型中原始類型的正确了解。它們之間的第二點差別是，你可以把任何帶參數的泛型類型傳遞給接受原始類型List的方法，但卻不能把List<String>傳遞給接受List<Object>的方法，因為會産生編譯錯誤。
12、Java中List<?>和List<Object>之間的差別是什麼?
這道題跟上一道題看起來很像，實質上卻完全不同。List<?> 是一個未知類型的List，而List<Object>其實是任意類型的List。你可以把List<String>, List<Integer>指派給List<?>，卻不能把List<String>指派給List<Object>。
List<?> listOfAnyType;
List<Object> listOfObject = new ArrayList<Object>();
List<String> listOfString = new ArrayList<String>();
List<Integer> listOfInteger = new ArrayList<Integer>();
listOfAnyType = listOfString; //legal
listOfAnyType = listOfInteger; //legal
listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types
13、List<String>和原始類型List之間的差別.
該題類似于“原始類型和帶參數類型之間有什麼差別”。帶參數類型是類型安全的，而且其類型安全是由編譯器保證的，但原始類型List卻不是類型安全的。你不能把String之外的任何其它類型的Object存入String類型的List中，而你可以把任何類型的對象存入原始List中。使用泛型的帶參數類型你不需要進行類型轉換，但是對于原始類型，你則需要進行顯式的類型轉換。
List listOfRawTypes = new ArrayList();
listOfRawTypes.add("abc");
listOfRawTypes.add(123); //編譯器允許這樣 - 運作時卻會出現異常
String item = (String) listOfRawTypes.get(0); //需要顯式的類型轉換
item = (String) listOfRawTypes.get(1); //抛ClassCastException，因為Integer不能被轉換為String
List<String> listOfString = new ArrayList();
listOfString.add("abcd");
listOfString.add(1234); //編譯錯誤，比在運作時抛異常要好
item = listOfString.get(0); //不需要顯式的類型轉換 - 編譯器自動轉換
通配符
通配符上界
正常使用
public class Test {
public static void printIntValue(List<? extends Number> list) {
for (Number number : list) {
System.out.print(number.intValue()+" ");
System.out.println();
List<Integer> integerList=new ArrayList<Integer>();
integerList.add(2);
printIntValue(integerList);
List<Float> floatList=new ArrayList<Float>();
floatList.add((float) 3.3);
floatList.add((float) 0.3);
printIntValue(floatList);
2 2
3 0
非法使用
public static void fillNumberList(List<? extends Number> list) {
list.add(new Integer(0));//編譯錯誤
list.add(new Float(1.0));//編譯錯誤
List<? extends Number> list=new ArrayList();
list.add(new Integer(1));//編譯錯誤
List<? extends Number>可以代表List<Integer>或List<Float>，為什麼不能像其中加入Integer或者Float呢？
首先，我們知道List<Integer>之中隻能加入Integer。并且如下代碼是可行的：
List<? extends Number> list1=new ArrayList<Integer>();
List<? extends Number> list2=new ArrayList<Float>();
假設前面的例子沒有編譯錯誤，如果我們把list1或者list2傳入方法fillNumberList，顯然都會出現類型不比對的情況，假設不成立。
是以，我們得出結論：不能往List<? extends T> 中添加任意對象，除了null。
那為什麼對List<? extends T>進行疊代可以呢，因為子類必定有父類相同的接口，這正是我們所期望的。
通配符下界
public static void fillNumberList(List<? super Number> list) {
list.add(new Integer(0));
list.add(new Float(1.0));
List<? super Number> list=new ArrayList();
list.add(new Integer(1));
list.add(new Float(1.1));
可以添加Number的任何子類，為什麼呢？
List<? super Number>可以代表List<T>，其中T為Number父類，（雖然Number沒有父類）。如果說，T為Number的父類，我們想List<T>中加入Number的子類肯定是可以的。
對List<? superT>進行疊代是不允許的。為什麼呢？你知道用哪種接口去疊代List嗎？隻有用Object類的接口才能保證集合中的元素都擁有該接口，顯然這個意義不大。其應用場景略。
無界通配符
知道了通配符的上界和下界，其實也等同于知道了無界通配符，不加任何修飾即可，單獨一個“？”。如List<?>，“？”可以代表任意類型，“任意”也就是未知類型。
List<Object>與List<?>并不等同，List<Object>是List<?>的子類。還有不能往List<?> list裡添加任意對象，除了null。
1、當方法是使用原始的Object類型作為參數時，如下：
public static void printList(List<Object> list) {
for (Object elem : list)
System.out.println(elem + "");
System.out.println();
可以選擇改為如下實作：
public static void printList(List<?> list) {
for (Object elem: list)
System.out.print(elem + "");
這樣就可以相容更多的輸出，而不單純是List<Object>,如下：
List<Integer> li = Arrays.asList(1, 2, 3);
List<String> ls = Arrays.asList("one", "two", "three");
printList(li);
printList(ls);
參考：
《Java核心技術 卷一》
http://blog.csdn.net/lonelyroamer/article/details/7868820
http://www.oschina.net/translate/10-interview-questions-on-java-generics
http://www.linuxidc.com/Linux/2013-10/90928.htm