Java泛型總結報告精選
篇一：Java泛型總結
1. 什么是泛型？
泛型（Generic type 或者 generics）是對 Java 語(yǔ)言的類(lèi)型系統的一種擴展，以支持創(chuàng )建可以按類(lèi)型進(jìn)行參數化的類(lèi)�？梢园杨�(lèi)型參數看作是使用參數化類(lèi)型時(shí)指定的類(lèi)型的一個(gè)占位符，就像方法的形式參數是運行時(shí)傳遞的值的占位符一樣。
可以在集合框架（Collection framework）中看到泛型的動(dòng)機。例如，Map 類(lèi)允許您向一個(gè) Map 添加任意類(lèi)的對象，即使最常見(jiàn)的情況是在給定映射（map）中保存某個(gè)特定類(lèi)型（比如 String）的對象。
因為 Map.get() 被定義為返回 Object，所以一般必須將 Map.get() 的結果強制類(lèi)型轉換為期望的類(lèi)型，如下面的代碼所示：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
要讓程序通過(guò)編譯，必須將 get() 的結果強制類(lèi)型轉換為 String，并且希望結果真的是一個(gè) String。但是有可能某人已經(jīng)在該映射中保存了不是 String 的東西，這樣的話(huà)，上面的代碼將會(huì )拋出 ClassCastException。
理想情況下，您可能會(huì )得出這樣一個(gè)觀(guān)點(diǎn)，即 m 是一個(gè) Map，它將 String 鍵映射到 String 值。這可以讓您消除代碼中的強制類(lèi)型轉換，同時(shí)獲得一個(gè)附加的類(lèi)型檢查層，該檢查層可以防止有人將錯誤類(lèi)型的鍵或值保存在集合中。這就是泛型所做的工作。
2. 泛型的好處
Java 語(yǔ)言中引入泛型是一個(gè)較大的功能增強。不僅語(yǔ)言、類(lèi)型系統和編譯器有了較大的變化，以支持泛型，而且類(lèi)庫也進(jìn)行了大翻修，所以許多重要的類(lèi)，比如集合框架，都已經(jīng)成為泛型化的了。這帶來(lái)了很多好處：
類(lèi)型安全。 泛型的主要目標是提高 Java 程序的類(lèi)型安全。通過(guò)知道使用泛型定義的變量的類(lèi)型限制，編譯器可以在一個(gè)高得多的程度上驗證類(lèi)型假設。沒(méi)有泛型，這些假設就只存在于程序員的頭腦中（或者如果幸運的話(huà)，還存在于代碼注釋中）。
Java 程序中的一種流行技術(shù)是定義這樣的集合，即它的元素或鍵是公共類(lèi)型的，比如“String 列表”或者“String 到 String 的映射”。通過(guò)在變量聲明中捕獲這一附加的類(lèi)型信息，泛型允許編譯器實(shí)施這些附加的類(lèi)型約束。類(lèi)型錯誤現在就可以在編譯時(shí)被捕獲了，而不是在運行時(shí)當作 ClassCastException 展示出來(lái)。將類(lèi)型檢查從運行時(shí)挪到編譯時(shí)有助于您更容易找到錯誤，并可提高程序的可靠性。
消除強制類(lèi)型轉換。 泛型的一個(gè)附帶好處是，消除源代碼中的許多強制類(lèi)型轉換。這使得代碼更加可讀，并且減少了出錯機會(huì )。
盡管減少強制類(lèi)型轉換可以降低使用泛型類(lèi)的代碼的羅嗦程度，但是聲明泛型變量會(huì )帶來(lái)相應的羅嗦。比較下面兩個(gè)代碼例子。
該代碼不使用泛型：
List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);
該代碼使用泛型：
Listli = new ArrayList();
li.put(new Integer(3));
Integer i = li.get(0);
在簡(jiǎn)單的程序中使用一次泛型變量不會(huì )降低羅嗦程度。但是對于多次使用泛型變量的大型程序來(lái)說(shuō)，則可以累積起來(lái)降低羅嗦程度。
潛在的性能收益。 泛型為較大的優(yōu)化帶來(lái)可能。在泛型的初始實(shí)現中，編譯器將強制類(lèi)型轉換（沒(méi)有泛型的話(huà)，程序員會(huì )指定這些強制類(lèi)型轉換）插入生成的字節碼中。但是更多類(lèi)型信息可用于編譯器這一事實(shí)，為未來(lái)版本的 JVM 的優(yōu)化帶來(lái)可能。
由于泛型的實(shí)現方式，支持泛型（幾乎）不需要 JVM 或類(lèi)文件更改。所有工作都在編譯器中完成，編譯器生成類(lèi)似于沒(méi)有泛型（和強制類(lèi)型轉換）時(shí)所寫(xiě)的代碼，只是更能確保類(lèi)型安全而已。
3. 泛型用法的例子
泛型的許多最佳例子都來(lái)自集合框架，因為泛型讓您在保存在集合中的元素上指定類(lèi)型約束�？紤]這個(gè)使用 Map 類(lèi)的例子，其中涉及一定程度的優(yōu)化，即 Map.get() 返回的結果將確實(shí)是一個(gè) String：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
如果有人已經(jīng)在映射中放置了不是 String 的其他東西，上面的代碼將會(huì )拋出 ClassCastException。泛型允許您表達這樣的類(lèi)型約束，即 m 是一個(gè)將 String 鍵映射到 String 值的 Map。這可以消除代碼中的強制類(lèi)型轉換，同時(shí)獲得一個(gè)附加的類(lèi)型檢查層，這個(gè)檢查層可以防止有人將錯誤類(lèi)型的鍵或值保存在集合中。
下面的代碼示例展示了 JDK 5.0 中集合框架中的 Map 接口的定義的一部分：
public interface Map{
public void put(K key, V value);
public V get(K key);
}
注意該接口的兩個(gè)附加物：
類(lèi)型參數 K 和 V 在類(lèi)級別的規格說(shuō)明，表示在聲明一個(gè) Map 類(lèi)型的變量時(shí)指定的類(lèi)型的占位符。
在 get()、put() 和其他方法的方法簽名中使用的 K 和 V。
為了贏(yíng)得使用泛型的好處，必須在定義或實(shí)例化 Map 類(lèi)型的變量時(shí)為 K 和 V 提供具體的值。以一種相對直觀(guān)的方式做這件事：
Mapm = new HashMap();
m.put("key", "blarg");
String s = m.get("key");
當使用 Map 的泛型化版本時(shí)，您不再需要將 Map.get() 的結果強制類(lèi)型轉換為 String，因為編譯器知道 get() 將返回一個(gè) String。
在使用泛型的版本中并沒(méi)有減少鍵盤(pán)錄入；實(shí)際上，比使用強制類(lèi)型轉換的版本需要做更多鍵入。使用泛型只是帶來(lái)了附加的類(lèi)型安全。因為編譯器知道關(guān)于您將放進(jìn) Map 中的鍵和值的類(lèi)型的更多信息，所以類(lèi)型檢查從執行時(shí)挪到了編譯時(shí)，這會(huì )提高可靠性并加快開(kāi)發(fā)速度。
向后兼容
在 Java 語(yǔ)言中引入泛型的一個(gè)重要目標就是維護向后兼容。盡管 JDK 5.0 的標準類(lèi)庫中的許多類(lèi)，比如集合框架，都已經(jīng)泛型化了，但是使用集合類(lèi)（比如 HashMap 和 ArrayList）的現有代碼將繼續不加修改地在 JDK 5.0 中工作。當然，沒(méi)有利用泛型的現有代碼將不會(huì )贏(yíng)得泛型的類(lèi)型安全好處。
4. 泛型基礎
4.1 類(lèi)型參數
在定義泛型類(lèi)或聲明泛型類(lèi)的變量時(shí)，使用尖括號來(lái)指定形式類(lèi)型參數。形式類(lèi)型參數與實(shí)際類(lèi)型參數之間的關(guān)系類(lèi)似于形式方法參數與實(shí)際方法參數之間的關(guān)系，只是類(lèi)型參數表示類(lèi)型，而不是表示值。
泛型類(lèi)中的類(lèi)型參數幾乎可以用于任何可以使用類(lèi)名的地方。例如，下面是 java.util.Map 接口的定義的摘錄：
public interface Map{
public void put(K key, V value);
public V get(K key);
}
Map 接口是由兩個(gè)類(lèi)型參數化的，這兩個(gè)類(lèi)型是鍵類(lèi)型 K 和值類(lèi)型 V。（不使用泛型）將會(huì )接受或返回 Object 的方法現在在它們的方法簽名中使用 K 或 V，指示附加的類(lèi)型約束位于 Map 的規格說(shuō)明之下。
當聲明或者實(shí)例化一個(gè)泛型的對象時(shí)，必須指定類(lèi)型參數的值：
Mapmap = new Ha
shMap();
注意，在本例中，必須指定兩次類(lèi)型參數。一次是在聲明變量 map 的類(lèi)型時(shí)，另一次是在選擇 HashMap 類(lèi)的參數化以便可以實(shí)例化正確類(lèi)型的一個(gè)實(shí)例時(shí)。
編譯器在遇到一個(gè) Map類(lèi)型的變量時(shí)，知道 K 和 V 現在被綁定為 String，因此它知道在這樣的變量上調用 Map.get() 將會(huì )得到 String 類(lèi)型。
除了異常類(lèi)型、枚舉或匿名內部類(lèi)以外，任何類(lèi)都可以具有類(lèi)型參數。
4.2 命名類(lèi)型參數
推薦的命名約定是使用大寫(xiě)的單個(gè)字母名稱(chēng)作為類(lèi)型參數。這與 C++ 約定有所不同（參閱 附錄 A：與 C++ 模板的比較），并反映了大多數泛型類(lèi)將具有少量類(lèi)型參數的假定。對于常見(jiàn)的泛型模式，推薦的名稱(chēng)是：
K —— 鍵，比如映射的鍵。
V —— 值，比如 List 和 Set 的內容，或者 Map 中的值。
E —— 異常類(lèi)。
T —— 泛型。
4.3 泛型不是協(xié)變的
關(guān)于泛型的混淆，一個(gè)常見(jiàn)的來(lái)源就是假設它們像數組一樣是協(xié)變的。其實(shí)它們不是協(xié)變的。List
不是 List的父類(lèi)型。
如果 A 擴展 B，那么 A 的數組也是 B 的數組，并且完全可以在需要 B[] 的地方使用 A[]：
Integer[] intArray = new Integer[10];
Number[] numberArray = intArray;
上面的代碼是有效的，因為一個(gè) Integer 是一個(gè) Number，因而一個(gè) Integer 數組是 一個(gè) Number 數組。但是對于泛型來(lái)說(shuō)則不然。下面的代碼是無(wú)效的：
ListintList = new ArrayList();
ListnumberList = intList; // invalid
最初，大多數 Java 程序員覺(jué)得這缺少協(xié)變很煩人，或者甚至是“壞的（broken）”，但是之所以這樣有一個(gè)很好的原因。如果可以將 List賦給 List，下面的代碼就會(huì )違背泛型應該提供的類(lèi)型安全：
ListintList = new ArrayList();
ListnumberList = intList; // invalid
numberList.add(new Float(3.1415));
因為 intList 和 numberList 都是有別名的，如果允許的話(huà)，上面的代碼就會(huì )讓您將不是 Integers 的東西放進(jìn) intList 中。但是，正如下一屏將會(huì )看到的，您有一個(gè)更加靈活的方式來(lái)定義泛型。
4.4 類(lèi)型通配符
假設您具有該方法：
void printList(List l) {
for (Object o : l)
System.out.println(o);
}
上面的代碼在 JDK 5.0 上編譯通過(guò)，但是如果試圖用 List調用它，則會(huì )得到警告。出現警告是因為，您將泛型（List）傳遞給一個(gè)只承諾將它當作 List（所謂的原始類(lèi)型）的方法，這將破壞使用泛型的類(lèi)型安全。
如果試圖編寫(xiě)像下面這樣的方法，那么將會(huì )怎么樣？
void printList(List
l) {
for (Object o : l)
System.out.println(o);
}
它仍然不會(huì )通過(guò)編譯，因為一個(gè) List不是 一個(gè) List
�。ㄕ缜耙黄� 泛型不是協(xié)變的 中所學(xué)的）。這才真正煩人 —— 現在您的泛型版本還沒(méi)有普通的非泛型版本有用！
解決方案是使用類(lèi)型通配符：
void printList(List l) {
for (Object o : l)
System.out.println(o);
}
上面代碼中的問(wèn)號是一個(gè)類(lèi)型通配符。它讀作“問(wèn)號”。List 是任何泛型 List 的父類(lèi)型，所以您完全可以將 List
、List或 List<List> 傳遞給 printList()。
4.5 類(lèi)型通配符的作用
類(lèi)型通配符中引入了類(lèi)型通配符，這讓您可以聲明 List 類(lèi)型的變量。您可以對這樣的 List 做什么呢？非常方便，可以從中檢索元素，但是不能添加元素。原因不是編譯器知道哪些方法修改列表哪些方法不修改列表，而是（大多數）變化的方法比不變化的方法需要更多的類(lèi)型信息。下面的代碼則工作得很好：
Listli = new ArrayList();
li.add(new Integer(42));
List lu = li;
System.out.println(lu.get(0));
為什么該代碼能工作呢？對于 lu，編譯器一點(diǎn)都不知道 List 的類(lèi)型參數的值。但是編譯器比較聰明，它可以做一些類(lèi)型推理。在本例中，它推斷未知的類(lèi)型參數必須擴展 Object。（這個(gè)特定的推理沒(méi)有太大的跳躍，但是編譯器可以作出一些非常令人佩服的類(lèi)型推理，后面就會(huì )看到（在底層細節一節中）。所以它讓您調用 List.get() 并推斷返回類(lèi)型為 Object。 另一方面，下面的代碼不能工作：
Listli = new ArrayList();
li.add(new Integer(42));
List lu = li;
lu.add(new Integer(43)); // error
在本例中，對于 lu，編譯器不能對 List 的類(lèi)型參數作出足夠嚴密的推理，以確定將 Integer 傳遞給 List.add() 是類(lèi)型安全的。所以編譯器將不允許您這么做。
以免您仍然認為編譯器知道哪些方法更改列表的內容哪些不更改列表內容，請注意下面的代碼將能工作，因為它不依賴(lài)于編譯器必須知道關(guān)于 lu 的類(lèi)型參數的任何信息：
Listli = new ArrayList();
li.add(new Integer(42));
List lu = li;
lu.clear();
4.6 泛型方法
�。ㄔ� 類(lèi)型參數 一節中）您已經(jīng)看到，通過(guò)在類(lèi)的定義中添加一個(gè)形式類(lèi)型參數列表，可以將類(lèi)泛型化。方法也可以被泛型化，不管它們定義在其中的類(lèi)是不是泛型化的。
泛型類(lèi)在多個(gè)方法簽名間實(shí)施類(lèi)型約束。在 List中，類(lèi)型參數 V 出現在 get()、add()、contains() 等方法的簽名中。當創(chuàng )建一個(gè) Map類(lèi)型的變量時(shí)，您就在方法之間宣稱(chēng)一個(gè)類(lèi)型約束。您傳遞給 add() 的值將與 get() 返回的值的類(lèi)型相同。
類(lèi)似地，之所以聲明泛型方法，一般是因為您想要在該方法的多個(gè)參數之間宣稱(chēng)一個(gè)類(lèi)型約束。例如，下面代碼中的 ifThenElse() 方法，根據它的第一個(gè)參數的布爾值，它將返回第二個(gè)或第三個(gè)參數：
publicT ifThenElse(boolean b, T first, T second) {
return b ? first : second;
}
注意，您可以調用 ifThenElse()，而不用顯式地告訴編譯器，您想要 T 的什么值。編譯器不必顯式地被告知 T 將具有什么值；它只知道這些值都必須相同。編譯器允許您調用下面的代碼，因為編譯器可以使用類(lèi)型推理來(lái)推斷出，替代 T 的 String 滿(mǎn)足所有的類(lèi)型約束： String s = ifThenElse(b, "a", "b");
類(lèi)似地，您可以調用：
Integer i = ifThenElse(b, new Integer(1), new Integer(2));
但是，編譯器不允許下面的代碼，因為沒(méi)有類(lèi)型會(huì )滿(mǎn)足所需的類(lèi)型約束：
String s = ifThenElse(b, "pi", new Float(3.14));
為什么您選擇使用泛型方法，而不是將類(lèi)型 T 添加到類(lèi)定義呢？（至少）有兩種情況應該這樣做：
當泛型方法是靜態(tài)的時(shí)，這種情況下不能使用類(lèi)類(lèi)型參數。
當 T 上的類(lèi)型約束對于方法真正是局部的時(shí)，這意味著(zhù)沒(méi)有在相同類(lèi)的另一個(gè)方法簽名中使用相同類(lèi)型 T 的約束。通過(guò)使得泛型方法的類(lèi)型參數對于方法是局部的，可以簡(jiǎn)化封閉類(lèi)型的簽名。
4.7 有限制類(lèi)型
在前一屏 泛型方法 的例子中，類(lèi)型參數 V 是無(wú)約束的或無(wú)限制的類(lèi)型。有時(shí)在還沒(méi)有完全指定類(lèi)型參數時(shí)，需要對類(lèi)型參數指定附加的約束。
考慮例子 Matrix 類(lèi)，它使用類(lèi)型參數 V，該參數由 Number 類(lèi)來(lái)限制：
public class Matrix{ ... }
編譯器允許您創(chuàng )建 Matrix或 Matrix類(lèi)型的變量，但是如果您試圖定義
篇二：java泛型基礎知識總結
Java泛型
Java泛型是java1.5中引入的新特性，在此之前，java通過(guò)對類(lèi)型Object的引用來(lái)實(shí)現參數類(lèi)型的“任意化”，特點(diǎn)則是需要進(jìn)行顯示的強制類(lèi)型轉換。（而這種顯示的`類(lèi)型轉換可能是無(wú)法進(jìn)行的，是錯誤的）但編譯器無(wú)法發(fā)現強制類(lèi)型轉換可能引起的異常，異常只有在運行時(shí)才能出現，成為了系統的安全隱患。----------------------------為啥要進(jìn)入泛型這個(gè)概念 泛型的本質(zhì)是參數化類(lèi)型，及所操作的數據類(lèi)型被指定為一個(gè)參數，此參數類(lèi)型可以用在類(lèi)、接口、和方法的聲明及創(chuàng )建中，分別被稱(chēng)為泛型類(lèi)，泛型接口，及泛型方法。 使用注意事項：
泛型的類(lèi)型參數只能是類(lèi)類(lèi)型（包括自定義類(lèi)），但是不能是簡(jiǎn)單類(lèi)型 泛型類(lèi)型參數可以是多個(gè)
泛型的參數類(lèi)型還可以是通配符類(lèi)型
沒(méi)有泛型的錯誤：
Import java.util.*;
Public class NoGenericTypeDemo{
Public static void main(String[] args)
{
List names=new ArrayList();
Names.add("張桑拿");
Names.add(new Integer(2);
String nameFirst=(String)names.get(0);
String namesecond=(String)names.get(1);//拋出異常jav.lang.ClassCastException異常，而且編譯時(shí)沒(méi)有被發(fā)現
}
有時(shí)候需要使泛型變量能使用任何的類(lèi)型，此時(shí)可以使用通配符”？”否則可能需要編寫(xiě)許多版本的重載函數，使用通配符，使方法printLsit（）可以接受各種類(lèi)型的List對象，否則必須使用重載技術(shù)，
Public static void printList(Listlist)
{
//輸出集合中的元素
}
篇三：JAVA泛型的簡(jiǎn)單實(shí)例
簡(jiǎn)單普通類(lèi)
package test7;
import java.util.ArrayList;
class Student
{
int Number;
String Name;
String Cla;
public int GetNumber()
{
return Number;
}
public void SetNumber(int Number)
{
this.Number = Number;
}
public String GetName()
{
return Name;
}
public void SetName(String Name)
{
this.Name = Name;
}
public String GetCla()
{
return Cla;
}
public void SetCla(String Cla)
{
this.Cla = Cla;
}
public Student(){}
public Student(int Number,String Name,String Cla)
{
this.Number = Number;
this.Name = Name;
this.Cla = Cla;
}
}
public class test071 {
public static void main(String[] args) {
System.out.println("設計者：");
Student s1 = new Student(123, "張三", "11計科");
Student s2 = new Student(124, "李四", "11計科");
Student s3 = new Student(125, "王五", "11計科");
Student dujingjing = new Student(20110105,"杜","11計科");
ArrayList AL = new ArrayList();
AL.add(s1);
AL.add(s2);
AL.add(s3);
AL.add(dujingjing);
for(int i = 0;i<AL.size();i++)
{
Student s = (Student)AL.get(i);
System.out.println("學(xué)號：" +s.Number + " 姓名：" +s.Name+ " 班級：" +s.Cla);
}
}
}
簡(jiǎn)單泛型實(shí)例
java中泛型定義
Java的泛型類(lèi)就是一個(gè)用類(lèi)型作為參數的類(lèi)，即帶有參數化類(lèi)型的類(lèi)。就像我們定義類(lèi)的成員方法一樣。大家很熟悉Java的成員方法形式是method(String str，int i)，方法中參數str、i的值是可變的。而泛型也是一樣的：class泛型類(lèi)類(lèi)名，這里的K和V就像方法中的參數str和i，也是可變的。
Class UseT{
Private T x;
Public SetX(T x){````````}
}
package test7;
泛型類(lèi)：L2
class L2
{
private T obj;
public L2(T obj)
{
this.obj = obj;
}
public T getobj()
{
return this.obj;
}
public void setobj(T obj)
{
this.obj = obj;
}
public void showobj(T obj)
{
System.out.println("數據為：" + this.obj); }
}
主類(lèi)：
public class test072 {
public static void main(String[] args) {
System.out.println("設計者:");
L2name = new L2("汽車(chē)"); name.showobj(name.getobj());
L2data = new L2(12); data.showobj(data.getobj());
}
}
簡(jiǎn)單集合類(lèi)
篇四：java泛型總結
泛型總結篇：
1）泛型參數只能是類(lèi)類(lèi)型
例如：List// 報錯
List// 正確
2）泛型的類(lèi)型參數可以有多個(gè)！
例如：Listlist = new
ArrayList();
3）泛型的參數類(lèi)型可以使用extends，習慣稱(chēng)“有界類(lèi)型”，
例如：List，person為list的上界
4）泛型可以使用通配符類(lèi)型！“？” 相當于“Object”類(lèi)型，（注意不可逆） 例如：List //定義成這樣可以添加Object類(lèi)型到List里面去 List
; //定義成這樣不可以添加String類(lèi)型到List里面去 List; // 這樣就可以互等了！這樣還可以設定泛型的上限
5）帶泛型的類(lèi)，構造方法寫(xiě)法不變，其后不可以加泛型！
例如：class Student{
public Student(){} // 構造方法這樣寫(xiě)就錯了
}
6）List不是 List
的子類(lèi)！，不可以把前者看成后者的子類(lèi)，所以不
可以把前者的實(shí)例賦給后者
例如： ListSlist = new ArrayList();
Slist.add(new String("abc"));
List
Olist = new ArrayList
();
Olist.add("abc");
Olist = Slist; // 報錯！
7）帶不同泛型參數的實(shí)例可以共享類(lèi)的靜態(tài)方法和靜態(tài)變量，所以靜態(tài)方法和靜態(tài)變量
申明的時(shí)候不可以使用類(lèi)型行參
例如：class Cup{
static T info; // 報錯！
public static setInfo(T info){}； // 報錯！
}
8）帶不同泛型參數的類(lèi)是共享一個(gè)字節碼文件的！反編譯過(guò)后泛型參數就被擦除了
例如：ListSlist = new ArrayList();
Slist.add(new String("aaa"));
ListIlist = new ArrayList();
Ilist.add(new Integer(100));
System.out.println(Slist.getClass()==Ilist.getClass()); 結果為true；
9）當使用定義了泛型參數的接口 和 父類(lèi)的時(shí)候！就不能在帶參數了 例如：class Sub extends Father{} // 錯誤
10）
class T{}
public class typeTest extends T{}//報錯
class T{}
public class typeTest extends T{} // 正確 可使用String等基本封裝類(lèi)型
class T{}
class Student{}
public class typeTest extends T{} // 這樣也正確
11） 泛型方法 ，泛型方法的參數的作用域僅在本方法，要和方法帶泛型區分開(kāi)！ Staticvoid test(ListS_list){} // 泛型參數要放在返回類(lèi)型前
12）帶有泛型的代碼轉換成沒(méi)有泛型的代碼由javac完成，虛擬機不處理這些事情！
這種技術(shù)叫做 “擦除”；
例如：class Food{
T size;
public Food(T size){} //注意構造方法不可以帶泛型參數！
public void setSize(){ this.size = size; }
public T getSize(){ return this.size;}
}
public class test{
public static void main(String arg[]){
Fooda = new Food(6);
Ingeger as = a.getSize(); // 返回的是Integer的類(lèi)型 Food b = a; //把a對象賦給Food變量；泛型參數類(lèi)型會(huì )丟失 即擦除；
Number size1 = b.getSize(); // b只知道size的類(lèi)型是Number // Integer in = b.getSize(); 這樣是編譯錯誤的！
} }
篇五：Java泛型簡(jiǎn)明教程
導讀：本文是從《Java Generics Quick Tutorial》這篇文章翻譯而來(lái)，譯文來(lái)自外刊IT評論《Java泛型簡(jiǎn)明教程》。內容如下：
泛型是Java SE 5.0中引入的一項特征，自從這項語(yǔ)言特征出現多年來(lái)，我相信，幾乎所有的Java程序員不僅聽(tīng)說(shuō)過(guò)，而且使用過(guò)它。關(guān)于Java泛型的教程，免費的，不免費的，有很多。我遇到的最好的教材有：
The Java Tutorial
Java Generics and Collections, by Maurice Naftalin and Philip Wadler
Effective Java中文版(第2版), by Joshua Bloch.
盡管有這么多豐富的資料，有時(shí)我感覺(jué)，有很多的程序員仍然不太明白Java泛型的功能和意義。這就是為什么我想使用一種最簡(jiǎn)單的形式來(lái)總結一下程序員需要知道的關(guān)于Java泛型的最基本的知識。
Java泛型由來(lái)的動(dòng)機
理解Java泛型最簡(jiǎn)單的方法是把它看成一種便捷語(yǔ)法，能節省你某些Java類(lèi)型轉換(casting)上的操作：
1. Listbox = ...;
2. Apple apple = box.get(0);
上面的代碼自身已表達的很清楚：box是一個(gè)裝有Apple對象的List。get方法返回一個(gè)Apple對象實(shí)例，這個(gè)過(guò)程不需要進(jìn)行類(lèi)型轉換。沒(méi)有泛型，上面的代碼需要寫(xiě)成這樣：
1. List box = ...;
2. Apple apple = (Apple) box.get(0);
很明顯，泛型的主要好處就是讓編譯器保留參數的類(lèi)型信息，執行類(lèi)型檢查，執行類(lèi)型轉換操作：編譯器保證了這些類(lèi)型轉換的絕對無(wú)誤。
相對于依賴(lài)程序員來(lái)記住對象類(lèi)型、執行類(lèi)型轉換——這會(huì )導致程序運行時(shí)的失敗，很難調試和解決，而編譯器能夠幫助程序員在編譯時(shí)強制進(jìn)行大量的類(lèi)型檢查，發(fā)現其中的錯誤。 泛型的構成
由泛型的構成引出了一個(gè)類(lèi)型變量的概念。根據Java語(yǔ)言規范，類(lèi)型變量是一種沒(méi)有限制的標志符，產(chǎn)生于以下幾種情況：
泛型類(lèi)聲明
泛型接口聲明
泛型方法聲明
泛型構造器(constructor)聲明
泛型類(lèi)和接口
如果一個(gè)類(lèi)或接口上有一個(gè)或多個(gè)類(lèi)型變量，那它就是泛型。類(lèi)型變量由尖括號界定，放在類(lèi)或接口名的后面：
1. public interface Listextends Collection{
2.
3. ...
4. }
簡(jiǎn)單的說(shuō)，類(lèi)型變量扮演的角色就如同一個(gè)參數，它提供給編譯器用來(lái)類(lèi)型檢查的信息。 Java類(lèi)庫里的很多類(lèi)，例如整個(gè)Collection框架都做了泛型化的修改。例如，我們在上面的第一段代碼里用到的List接口就是一個(gè)泛型類(lèi)。在那段代碼里，box是一個(gè)List對象，它是一個(gè)帶有一個(gè)Apple類(lèi)型變量的List接口的類(lèi)實(shí)現的實(shí)例。編譯器使用這個(gè)類(lèi)型變量參數在get方法被調用、返回一個(gè)Apple對象時(shí)自動(dòng)對其進(jìn)行類(lèi)型轉換。 實(shí)際上，這新出現的泛型標記，或者說(shuō)這個(gè)List接口里的get方法是這樣的：
1. T get(int index);
get方法實(shí)際返回的是一個(gè)類(lèi)型為T(mén)的對象，T是在List聲明中的類(lèi)型變量。 泛型方法和構造器(Constructor)
非常的相似，如果方法和構造器上聲明了一個(gè)或多個(gè)類(lèi)型變量，它們也可以泛型化。
1. public staticT getFirst(Listlist)
這個(gè)方法將會(huì )接受一個(gè)List類(lèi)型的參數，返回一個(gè)T類(lèi)型的對象。
例子
你既可以使用Java類(lèi)庫里提供的泛型類(lèi)，也可以使用自己的泛型類(lèi)。
類(lèi)型安全的寫(xiě)入數據…
下面的這段代碼是個(gè)例子，我們創(chuàng )建了一個(gè)List實(shí)例，然后裝入一些數據：
1. Liststr = new ArrayList();
2.
3. str.add("Hello ");
4.
5. str.add("World.");
如果我們試圖在List裝入另外一種對象，編譯器就會(huì )提示錯誤：
1. str.add(1); //不能編譯
類(lèi)型安全的讀取數據…
當我們在使用List對象時(shí)，它總能保證我們得到的是一個(gè)String對象：
1. String myString = str.get(0);
遍歷
類(lèi)庫中的很多類(lèi)，諸如Iterator，功能都有所增強，被泛型化。List接口里的 iterator()方法現在返回的是Iterator，由它的T next()方法返回的對象不需要再進(jìn)行類(lèi)型轉換，你直接得到正確的類(lèi)型。
1. for (Iteratoriter = str.iterator(); iter.hasNext();){
2.
3. String s = iter.next();
4.
5. System.out.print(s);
6.
7. }
使用foreach
“for each”語(yǔ)法同樣受益于泛型。前面的代碼可以寫(xiě)出這樣：
1. for (String s: str){
2.
3. System.out.print(s);
4.
5. }
這樣既容易閱讀也容易維護。
自動(dòng)封裝(Autoboxing)和自動(dòng)拆封(Autounboxing)
在使用Java泛型時(shí)，autoboxing/autounboxing這兩個(gè)特征會(huì )被自動(dòng)的用到，就像下面的這段代碼：
1. Listints = new ArrayList();
2.
3. ints.add(0);
4.
5. ints.add(1);
6.
7.
8.
9.
10.int sum = 0;
11.
12.for (int i : ints){
13.
14.sum += i;
15.
16.}
然而，你要明白的一點(diǎn)是，封裝和解封會(huì )帶來(lái)性能上的損失，所有，通用要謹慎的使用。 子類(lèi)型
在Java中，跟其它具有面向對象類(lèi)型的語(yǔ)言一樣，類(lèi)型的層級可以被設計成這樣：
在Java中，類(lèi)型T的子類(lèi)型既可以是類(lèi)型T的一個(gè)擴展，也可以是類(lèi)型T的一個(gè)直接或非直接實(shí)現(如果T是一個(gè)接口的話(huà))。因為“成為某類(lèi)型的子類(lèi)型”是一個(gè)具有傳遞性質(zhì)的關(guān)系，如果類(lèi)型A是B的一個(gè)子類(lèi)型，B是C的子類(lèi)型，那么A也是C的子類(lèi)型。在上面的圖中： FujiApple(富士蘋(píng)果)是Apple的子類(lèi)型
Apple是Fruit(水果)的子類(lèi)型
FujiApple(富士蘋(píng)果)是Fruit(水果)的子類(lèi)型
所有Java類(lèi)型都是Object類(lèi)型的子類(lèi)型。
B類(lèi)型的任何一個(gè)子類(lèi)型A都可以被賦給一個(gè)類(lèi)型B的聲明：
1. Apple a = ...;
2. Fruit f = a;
泛型類(lèi)型的子類(lèi)型
如果一個(gè)Apple對象的實(shí)例可以被賦給一個(gè)Fruit對象的聲明，就像上面看到的，那么，List和 a List之間又是個(gè)什么關(guān)系呢？更通用些，如果類(lèi)型A是類(lèi)型B的子類(lèi)型，那C 和 C之間是什么關(guān)系？
答案會(huì )出乎你的意料：沒(méi)有任何關(guān)系。用更通俗的話(huà)，泛型類(lèi)型跟其是否子類(lèi)型沒(méi)有任何關(guān)系。
【Java泛型總結報告精選】相關(guān)文章：
實(shí)習總結報告（精選9篇）12-29
雇傭型合同04-25
季度個(gè)人總結報告01-19
員工述職總結報告10-11
會(huì )議總結報告范文01-12
月度會(huì )議總結報告08-18
商務(wù)公函談判型公函12-05
會(huì )議的總結報告范文01-09
會(huì )議組織總結報告結尾01-28