1、在你建立引數化型別的一個例項時，編譯器會為你負責轉型操作，並且保證型別的正確性。泛型的主要目的之一就是用來指定容器要持有什麼型別的物件，而且由編譯器來保證型別的正確性。示例：

public class Holder<T>{

private T a;

public Holder(T a){

this.a = a;

}

public T get(){

return a;

}

public void set(T a){

this.a = a;

}

public static void main(String[] args){

Holder<Test> h = new Holder<Test>(new Test());

Test t = h.get();

//h.set("test a stirng");error

}

}

現在，當你建立Holder物件時，必須指明想持有什麼型別的物件，將其置於尖括號內。就像main()中那樣。那麼，你就只能在Holder中存入該型別（或其子類）了。並且，在你從Hodler中去取出它持有的物件時，自動地就是正確的型別。

這就是Java泛型的核心概念：告訴編譯器想使用什麼型別，然後編譯器幫你處理一切細節。

2、Java泛型的侷限性：基本型別無法作為型別引數。不過，Java SE5具備了自動打包和拆包的功能，可以很方便的在基本型別和包裝類之間進行轉換。

3、是否擁有泛型方法，與其所在的類是否是泛型類沒有關係。

4、關於泛型方法的一個基本的指導原則：無論何時，只要你能做到，你就應該使用泛型方法。也就是說，如果使用泛型方法可以取代整個類泛型化，那麼就應該只使用泛型方法，因為它可以使事情更清楚明白。

5、型別推斷只對賦值操作有效，其他的時候並不起作用。示例：

List<String> l = new ArrayList<>();

而public static <k,v> Map<k,v> map(){

return new HashMap<k,v>();

}

f(Test.Map())；由此此時並非賦值操作，這時編譯器並不會執行型別推斷，編譯器認為：呼叫泛型方法後，其返回值被賦值給了一個Object型別的變數。解決方式是：使用顯式的型別說明。f(Test.<String,String>Map());只有在編寫非賦值語句的時候，我們才需要這樣的額外說明。

6、在泛型程式碼內部，你無法獲得任何有關泛型引數型別的資訊。即：你可以知道諸如型別引數識別符號和泛型型別邊界這類的資訊，你無法知道用來建立某個特定例項的實際的型別引數。原因是Java泛型是通過擦除來實現的，因為這任何具體的型別資訊都會被擦出了，你唯一知道的是你在使用一個物件，因此List<String>和List<Long>在執行時事實上是相同的型別，這兩種形式都被擦除成它們的原始型別：List。

7、型別邊界

與Java相比（Java的設計靈感來源於C++），C++模板實現了真正意義上的泛型：

template<Class T> class Test{

T object;

public :Test(T t){

this.object = t;

}

void operate(){

object.f();

}}

class HasF{

public：void  f(){

.....

}

}

當例項化這個模板的時候，C++編譯器將進行檢查，因此在Test<HasF>被例項化的這一刻，它會看到HasF擁有一個f()方法。如果情況並非如此，就會得到一個編譯器錯誤，這樣型別安全就得到了保障。但是，Java泛型就不同了：

public class HasF{

public void f(){

System.out.println("F()");

}

public class Test<T>{

private T object;

public Test(T t){

this.object  = t;

}

public void operate(){

objecte.f();//error

}

public static void main(String[] args){

HasF hasf = new HasF();

Test<HasF> test = new Test<HasF>(hasf);

test.operate();

｝

}

由於有了擦出，Java編譯器無法將operate必須能夠在object上呼叫f（）這一需求對映到HasF擁有f（）這一事實上。為了可以呼叫f()方法，我們必須協助泛型類，給定泛型類的邊界，例如：T extends HasF。我們說泛型型別引數將擦出到它的第一個邊界（它可能會有多個邊界），編譯器會把型別引數替換為它的擦出，像T extends HasF，T擦出到HasF，就好像在類的宣告中用HasF替換了一樣。

擦出的代價是顯著的。泛型不能用於顯示地引用執行時型別的操作之中，例如轉型、instanceof操作和new表示式。因為所有 關於引數的型別資訊都丟失了。因此也就喪失了在泛型程式碼中執行某些操作的能力，任何在執行時需要知道確切型別資訊的操作都無法工作。

8、擦出的補償：型別標籤 -- Class物件，這意味著你需要顯式的傳遞你的型別的Class物件，以便你可以在型別表示式中使用它。例如，對instanceof的嘗試失敗了，是因為其型別資訊已經被擦出了，如果引入型別標籤，你就可以轉而使用動態的isInstance():

public class TestB<T>{

class<T> kind;

public boolean f(Object obj){

return kind.isInstance(obg);

}

}

同樣，new T()操作失敗，部分原因是因為擦出，而另一個原因 是因為編譯器不能驗證T是否有預設的建構函式。同樣可以使用型別標籤Class物件來解決這個問題：注意：因為newInstance會呼叫預設建構函式，但是並非所有的類都有預設建構函式的，比如Integer。因此Sun建議使用顯示的工廠模式：

9、泛型陣列

我們不能直接建立泛型陣列，一般的解決方案是在任何想建立泛型陣列的地方使用ArrayList，例如private List<T> array = new ArrayList<T>();這裡你將獲得陣列的行為，以及由泛型提供的編譯期的型別安全。

成功的建立泛型陣列的唯一方式是建立一個被擦出型別的新陣列，然後對其轉型。

T[] array = (T[])new Object[size];

因為有了擦除，陣列的執行時型別就只能是Object[]。如果我們立即將其轉型為T[]，那麼在編譯期該陣列的實際型別就將丟失，而編譯器可能會錯過某些潛在的錯誤檢查。

正因為這樣，所以我們應該在使用陣列元素的時候，新增一個對T的轉型。

10、萬用字元

先看一下陣列的一種特殊的行為：可以向子型別陣列賦予基型別的陣列引用

class Fruit{}

class  Apple extends Fruit{}

class Jonathan extends Apple{}

class Orange extends Fruit{}

Fruit[] fruit = new Apple[10];

fruit[0] = new Apple();//ok

fruit[1] = new Jonathan();//ok

fruit[2] = new Fruit();//complier allows you to add fruit,but in runtime you will get a ArrayStoreException

最後一行程式碼為啥會得到一個異常呢？因為fruit的實際陣列型別是Apple[]，你應該只能在其中放置Apple或Apple的子類。又因為fruit的宣告是一個Fruit[]引用 -- 它有什麼理由不允許將Fruit物件或者任何從Fruit繼承而來的物件，放置到這個陣列呢。因此，在編譯期，這是允許的。但是，執行時的陣列機制知道它處理的是Apple[]，因此會在陣列中放置型別時丟擲異常。所以很明顯，陣列物件可以保留有關它們包含的物件型別的規則。就好像陣列對它們持有的物件是有意識的。

對陣列的這種賦值並不是那麼可怕，因為在執行時可以發現你已經插入了不正確的型別。但是，泛型的主要目標之一是將這種錯誤檢測移入到編譯期。因此，當我們檢視使用泛型容器代替陣列的時候，會發生什麼？

List<Fruit> flist = new ArrayList<Apple>();//很顯然，會產生編譯錯誤，由於編譯器不能對該行程式碼瞭解足夠多的資訊，因此拒絕向上轉型的，實際上這根本不是向上轉型，因為Apple的List在型別上不等價於Fruit的List。

與陣列不同，泛型沒有內建的協変型別。這是因為陣列在語言中是完全定義的，因此內建了編譯期和執行時的檢查，但是在使用泛型時，編譯器和執行時系統都不知道你想用什麼型別做些什麼，以及應該採用什麼樣的規則。

但是，有時你想要在兩個型別之間建立某種型別的向上轉型關係，這正是萬用字元所允許的。

List<? extends Fruit> flist = new ArrayList<Apple>();//ok

//complie error

flist.add(new Apple());

flist.add(new Fruit());

flist.add(new Object());

萬用字元引用的是明確的型別，你無法向flist放置任何一個物件，因為一旦執行這種型別的向上轉型，你就將丟失掉向其中傳遞任何物件的能力，甚至是傳遞Object都不行。

Fruit f = flist.get(0);

如上程式碼是安全的，因為這個List中的任何物件至少具有Fruit型別，因此編譯器允許這麼做。

11、超型別萬用字元

<? super MyClass>可以宣告萬用字元是由某個特定類的任何基類來界定的，甚至可以使用型別引數：<？super T>（儘管你不能對泛型引數給出一個超型別邊界：即不能宣告<T super Myclass>）。這使得你可以安全的傳遞一個型別物件到泛型型別中。因此，有了超型別萬用字元就可以向集合中寫入了：

public void weiteTo(List<? super Apple> apples){

apples.add(new Apple());

apples.add(new Jonathan());

apples.add(new Fruit());//Error

}

捕獲轉換：

有一種情況特別需要使用<?>而不是原生型別。如果向一個使用<?>的方法傳遞原生型別，那麼對編譯器來說，可能會推斷出實際的型別引數，使得這個方法可以迴轉並呼叫另一個使用這個確切型別的方法。這種技術被稱為“捕獲轉換”；

public class CaptureConversion{

static <T> void f1(Holder<T> holder){

T t = holder.get();

System.out.println(t.getClass().getSimpleName());

}

static void f2(Holder<?> holder){

f1(holder);

}

main方法中呼叫：

Holder raw = new Holder<Integer>(1);

f1(raw);//有warning

f2(raw);沒有warining

}

f1()中的型別引數都是確切的，沒有萬用字元或邊界。在f2（）中，Holder引數是一個無界萬用字元，因此它看起來是未知的。但是，在f2（）中，f1（）被呼叫，而f1（）需要一個已知引數。這裡發生的是：引數型別在呼叫f2（）的過程中被捕獲，因此可以在對f1（）的呼叫中被使用。捕獲轉換隻有在這樣的情況下可以工作：即在方法內部，你需要知道確切的型別。

12、Java泛型的限制之一是：不能將基本型別用作型別引數。解決之道是使用基本型別的包裝器類以及Java SE5的自動包裝機制。示例：

List<Integer> list = new ArrayList<Integer>();

list.add(5);

注意：自動包裝機制解決了一些問題，但是並不是解決了所有的問題：自動包裝機制不能應用於陣列，因此這無法工作。示例：

class FArray{

public static <T> T[]  fill(T[] a,Generator<T> gen){

for(int i=0;i<a.length;i++){

a[i] = gen.next();

}

return a;

}

main方法中呼叫：

Integer[] integer = FArray.fill(new Integer[7],new RandomGenerator.Integer（）;//ok

FArray.fill(new int[7],new RandomIntGenerator());//error，無法自動包裝

}

13、自限定型別

自限定所做的，就是要求在繼承關係中，向下面這樣使用這個類：（對使用自限定的每個類的要求）

class A extends SelfBounded<A>{}

這會強制要求將正在定義的類當做引數傳遞給基類。

示例：

class SelfBounded<T extends SeleBounded<T>>{

T element;

SelfBounded<T> set(T arg){

element = arg;

return this;

}

T get(){return element;}

}

class A extends SelfBounded<A>{}

class B extends SelfBounded<A>{}//also ok

class D{}

class E extends SelfBounds<D>{}//complie error:D 不是自限定型別

自限定的引數的意義是什麼呢？它可以保證型別引數必須與正在被定義的類相同。還有，自限定限制只能強制作用於繼承關係。還可以將自限定用於泛型方法。

14、由於擦除的原因，將泛型應用於異常是非常受限的。catch語句不能捕獲泛型型別的異常。因為在編譯期和執行時都必須知道異常的確切型別。泛型類也不能直接或間接繼承自Throwable。但是，型別引數可能會在一個方法的throws子句中用到。這使得你可以編寫隨檢查型異常的型別而發生變化的泛型程式碼：

interface Processor<T,E extends Exception>{

void process(List<T> result) throws E;

}

Processor執行process（），並且可能會丟擲具有型別E的異常。