Java泛型總結(jié)報(bào)告

時(shí)間：2020-11-25 18:34:53 報(bào)告我要投稿

Java泛型總結(jié)報(bào)告精選

　　篇一：Java泛型總結(jié)

　　1. 什么是泛型？

Java泛型總結(jié)報(bào)告精選

　　泛型（Generic type 或者 generics）是對 Java 語言的類型系統(tǒng)的一種擴(kuò)展，以支持創(chuàng)建可以按類型進(jìn)行參數(shù)化的類。可以把類型參數(shù)看作是使用參數(shù)化類型時(shí)指定的類型的一個(gè)占位符，就像方法的形式參數(shù)是運(yùn)行時(shí)傳遞的值的占位符一樣。

　　可以在集合框架（Collection framework）中看到泛型的動(dòng)機(jī)。例如，Map 類允許您向一個(gè) Map 添加任意類的對象，即使最常見的情況是在給定映射（map）中保存某個(gè)特定類型（比如 String）的對象。

　　因?yàn)?Map.get() 被定義為返回 Object，所以一般必須將 Map.get() 的結(jié)果強(qiáng)制類型轉(zhuǎn)換為期望的類型，如下面的代碼所示：

　　Map m = new HashMap();

　　m.put("key", "blarg");

　　String s = (String) m.get("key");

　　要讓程序通過編譯，必須將 get() 的結(jié)果強(qiáng)制類型轉(zhuǎn)換為 String，并且希望結(jié)果真的是一個(gè) String。但是有可能某人已經(jīng)在該映射中保存了不是 String 的東西，這樣的話，上面的代碼將會(huì)拋出 ClassCastException。

　　理想情況下，您可能會(huì)得出這樣一個(gè)觀點(diǎn)，即 m 是一個(gè) Map，它將 String 鍵映射到 String 值。這可以讓您消除代碼中的強(qiáng)制類型轉(zhuǎn)換，同時(shí)獲得一個(gè)附加的類型檢查層，該檢查層可以防止有人將錯(cuò)誤類型的鍵或值保存在集合中。這就是泛型所做的工作。

　　2. 泛型的好處

　　Java 語言中引入泛型是一個(gè)較大的功能增強(qiáng)。不僅語言、類型系統(tǒng)和編譯器有了較大的變化，以支持泛型，而且類庫也進(jìn)行了大翻修，所以許多重要的類，比如集合框架，都已經(jīng)成為泛型化的了。這帶來了很多好處：

　　類型安全。泛型的主要目標(biāo)是提高 Java 程序的類型安全。通過知道使用泛型定義的變量的類型限制，編譯器可以在一個(gè)高得多的程度上驗(yàn)證類型假設(shè)。沒有泛型，這些假設(shè)就只存在于程序員的頭腦中（或者如果幸運(yùn)的話，還存在于代碼注釋中）。

　　Java 程序中的一種流行技術(shù)是定義這樣的集合，即它的元素或鍵是公共類型的，比如“String 列表”或者“String 到 String 的映射”。通過在變量聲明中捕獲這一附加的類型信息，泛型允許編譯器實(shí)施這些附加的類型約束。類型錯(cuò)誤現(xiàn)在就可以在編譯時(shí)被捕獲了，而不是在運(yùn)行時(shí)當(dāng)作 ClassCastException 展示出來。將類型檢查從運(yùn)行時(shí)挪到編譯時(shí)有助于您更容易找到錯(cuò)誤，并可提高程序的可靠性。

　　消除強(qiáng)制類型轉(zhuǎn)換。泛型的一個(gè)附帶好處是，消除源代碼中的許多強(qiáng)制類型轉(zhuǎn)換。這使得代碼更加可讀，并且減少了出錯(cuò)機(jī)會(huì)。

　　盡管減少強(qiáng)制類型轉(zhuǎn)換可以降低使用泛型類的代碼的羅嗦程度，但是聲明泛型變量會(huì)帶來相應(yīng)的羅嗦。比較下面兩個(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);

　　在簡單的程序中使用一次泛型變量不會(huì)降低羅嗦程度。但是對于多次使用泛型變量的大型程序來說，則可以累積起來降低羅嗦程度。

　　潛在的性能收益。泛型為較大的優(yōu)化帶來可能。在泛型的初始實(shí)現(xiàn)中，編譯器將強(qiáng)制類型轉(zhuǎn)換（沒有泛型的話，程序員會(huì)指定這些強(qiáng)制類型轉(zhuǎn)換）插入生成的字節(jié)碼中。但是更多類型信息可用于編譯器這一事實(shí)，為未來版本的 JVM 的優(yōu)化帶來可能。

　　由于泛型的實(shí)現(xiàn)方式，支持泛型（幾乎）不需要 JVM 或類文件更改。所有工作都在編譯器中完成，編譯器生成類似于沒有泛型（和強(qiáng)制類型轉(zhuǎn)換）時(shí)所寫的代碼，只是更能確保類型安全而已。

　　3. 泛型用法的例子

　　泛型的許多最佳例子都來自集合框架，因?yàn)榉盒妥屇诒４嬖诩现械脑厣现付愋图s束。考慮這個(gè)使用 Map 類的例子，其中涉及一定程度的優(yōu)化，即 Map.get() 返回的結(jié)果將確實(shí)是一個(gè) String：

　　Map m = new HashMap();

　　m.put("key", "blarg");

　　String s = (String) m.get("key");

　　如果有人已經(jīng)在映射中放置了不是 String 的其他東西，上面的代碼將會(huì)拋出 ClassCastException。泛型允許您表達(dá)這樣的類型約束，即 m 是一個(gè)將 String 鍵映射到 String 值的 Map。這可以消除代碼中的強(qiáng)制類型轉(zhuǎn)換，同時(shí)獲得一個(gè)附加的類型檢查層，這個(gè)檢查層可以防止有人將錯(cuò)誤類型的鍵或值保存在集合中。

　　下面的代碼示例展示了 JDK 5.0 中集合框架中的 Map 接口的定義的一部分：

　　public interface Map{

　　public void put(K key, V value);

　　public V get(K key);

　　}

　　注意該接口的兩個(gè)附加物：

　　類型參數(shù) K 和 V 在類級別的規(guī)格說明，表示在聲明一個(gè) Map 類型的變量時(shí)指定的類型的占位符。

　　在 get()、put() 和其他方法的方法簽名中使用的 K 和 V。

　　為了贏得使用泛型的好處，必須在定義或?qū)嵗?Map 類型的變量時(shí)為 K 和 V 提供具體的值。以一種相對直觀的方式做這件事：

　　Mapm = new HashMap();

　　m.put("key", "blarg");

　　String s = m.get("key");

　　當(dāng)使用 Map 的泛型化版本時(shí)，您不再需要將 Map.get() 的結(jié)果強(qiáng)制類型轉(zhuǎn)換為 String，因?yàn)榫幾g器知道 get() 將返回一個(gè) String。

　　在使用泛型的版本中并沒有減少鍵盤錄入；實(shí)際上，比使用強(qiáng)制類型轉(zhuǎn)換的版本需要做更多鍵入。使用泛型只是帶來了附加的類型安全。因?yàn)榫幾g器知道關(guān)于您將放進(jìn) Map 中的鍵和值的類型的更多信息，所以類型檢查從執(zhí)行時(shí)挪到了編譯時(shí)，這會(huì)提高可靠性并加快開發(fā)速度。

　　向后兼容

　　在 Java 語言中引入泛型的一個(gè)重要目標(biāo)就是維護(hù)向后兼容。盡管 JDK 5.0 的標(biāo)準(zhǔn)類庫中的許多類，比如集合框架，都已經(jīng)泛型化了，但是使用集合類（比如 HashMap 和 ArrayList）的現(xiàn)有代碼將繼續(xù)不加修改地在 JDK 5.0 中工作。當(dāng)然，沒有利用泛型的現(xiàn)有代碼將不會(huì)贏得泛型的類型安全好處。

　　4. 泛型基礎(chǔ)

　　4.1 類型參數(shù)

　　在定義泛型類或聲明泛型類的變量時(shí)，使用尖括號來指定形式類型參數(shù)。形式類型參數(shù)與實(shí)際類型參數(shù)之間的關(guān)系類似于形式方法參數(shù)與實(shí)際方法參數(shù)之間的關(guān)系，只是類型參數(shù)表示類型，而不是表示值。

　　泛型類中的類型參數(shù)幾乎可以用于任何可以使用類名的地方。例如，下面是 java.util.Map 接口的定義的摘錄：

　　public interface Map{

　　public void put(K key, V value);

　　public V get(K key);

　　}

　　Map 接口是由兩個(gè)類型參數(shù)化的，這兩個(gè)類型是鍵類型 K 和值類型 V。（不使用泛型）將會(huì)接受或返回 Object 的方法現(xiàn)在在它們的方法簽名中使用 K 或 V，指示附加的類型約束位于 Map 的規(guī)格說明之下。

　　當(dāng)聲明或者實(shí)例化一個(gè)泛型的對象時(shí)，必須指定類型參數(shù)的值：

　　Mapmap = new Ha

　　shMap();

　　注意，在本例中，必須指定兩次類型參數(shù)。一次是在聲明變量 map 的類型時(shí)，另一次是在選擇 HashMap 類的參數(shù)化以便可以實(shí)例化正確類型的一個(gè)實(shí)例時(shí)。

　　編譯器在遇到一個(gè) Map類型的變量時(shí)，知道 K 和 V 現(xiàn)在被綁定為 String，因此它知道在這樣的變量上調(diào)用 Map.get() 將會(huì)得到 String 類型。

　　除了異常類型、枚舉或匿名內(nèi)部類以外，任何類都可以具有類型參數(shù)。

　　4.2 命名類型參數(shù)

　　推薦的命名約定是使用大寫的單個(gè)字母名稱作為類型參數(shù)。這與 C++ 約定有所不同（參閱附錄 A：與 C++ 模板的比較），并反映了大多數(shù)泛型類將具有少量類型參數(shù)的假定。對于常見的泛型模式，推薦的名稱是：

　　K —— 鍵，比如映射的鍵。

　　V —— 值，比如 List 和 Set 的內(nèi)容，或者 Map 中的值。

　　E —— 異常類。

　　T —— 泛型。

　　4.3 泛型不是協(xié)變的

　　關(guān)于泛型的混淆，一個(gè)常見的來源就是假設(shè)它們像數(shù)組一樣是協(xié)變的。其實(shí)它們不是協(xié)變的。List

　　不是 List的父類型。

　　如果 A 擴(kuò)展 B，那么 A 的數(shù)組也是 B 的數(shù)組，并且完全可以在需要 B[] 的地方使用 A[]：

　　Integer[] intArray = new Integer[10];

　　Number[] numberArray = intArray;

　　上面的代碼是有效的，因?yàn)橐粋€(gè) Integer 是一個(gè) Number，因而一個(gè) Integer 數(shù)組是一個(gè) Number 數(shù)組。但是對于泛型來說則不然。下面的代碼是無效的：

　　ListintList = new ArrayList();

　　ListnumberList = intList; // invalid

　　最初，大多數(shù) Java 程序員覺得這缺少協(xié)變很煩人，或者甚至是“壞的（broken）”，但是之所以這樣有一個(gè)很好的原因。如果可以將 List賦給 List，下面的代碼就會(huì)違背泛型應(yīng)該提供的類型安全：

　　ListintList = new ArrayList();

　　ListnumberList = intList; // invalid

　　numberList.add(new Float(3.1415));

　　因?yàn)?intList 和 numberList 都是有別名的，如果允許的話，上面的代碼就會(huì)讓您將不是 Integers 的東西放進(jìn) intList 中。但是，正如下一屏將會(huì)看到的，您有一個(gè)更加靈活的方式來定義泛型。

　　4.4 類型通配符

　　假設(shè)您具有該方法：

　　void printList(List l) {

　　for (Object o : l)

　　System.out.println(o);

　　}

　　上面的代碼在 JDK 5.0 上編譯通過，但是如果試圖用 List調(diào)用它，則會(huì)得到警告。出現(xiàn)警告是因?yàn)椋鷮⒎盒停↙ist）傳遞給一個(gè)只承諾將它當(dāng)作 List（所謂的原始類型）的方法，這將破壞使用泛型的類型安全。

　　如果試圖編寫像下面這樣的方法，那么將會(huì)怎么樣？

　　void printList(List

　　l) {

　　for (Object o : l)

　　System.out.println(o);

　　}

　　它仍然不會(huì)通過編譯，因?yàn)橐粋€(gè) List不是一個(gè) List

　　（正如前一屏泛型不是協(xié)變的中所學(xué)的）。這才真正煩人 —— 現(xiàn)在您的泛型版本還沒有普通的非泛型版本有用！

　　解決方案是使用類型通配符：

　　void printList(List l) {

　　for (Object o : l)

　　System.out.println(o);

　　}

　　上面代碼中的問號是一個(gè)類型通配符。它讀作“問號”。List 是任何泛型 List 的父類型，所以您完全可以將 List

　　、List或 List<List> 傳遞給 printList()。

　　4.5 類型通配符的作用

　　類型通配符中引入了類型通配符，這讓您可以聲明 List 類型的變量。您可以對這樣的 List 做什么呢？非常方便，可以從中檢索元素，但是不能添加元素。原因不是編譯器知道哪些方法修改列表哪些方法不修改列表，而是（大多數(shù)）變化的方法比不變化的方法需要更多的類型信息。下面的代碼則工作得很好：

　　Listli = new ArrayList();

　　li.add(new Integer(42));

　　List lu = li;

　　System.out.println(lu.get(0));

　　為什么該代碼能工作呢？對于 lu，編譯器一點(diǎn)都不知道 List 的類型參數(shù)的值。但是編譯器比較聰明，它可以做一些類型推理。在本例中，它推斷未知的類型參數(shù)必須擴(kuò)展 Object。（這個(gè)特定的推理沒有太大的跳躍，但是編譯器可以作出一些非常令人佩服的類型推理，后面就會(huì)看到（在底層細(xì)節(jié)一節(jié)中）。所以它讓您調(diào)用 List.get() 并推斷返回類型為 Object。另一方面，下面的代碼不能工作：

　　Listli = new ArrayList();

　　li.add(new Integer(42));

　　List lu = li;

　　lu.add(new Integer(43)); // error

　　在本例中，對于 lu，編譯器不能對 List 的類型參數(shù)作出足夠嚴(yán)密的推理，以確定將 Integer 傳遞給 List.add() 是類型安全的。所以編譯器將不允許您這么做。

　　以免您仍然認(rèn)為編譯器知道哪些方法更改列表的內(nèi)容哪些不更改列表內(nèi)容，請注意下面的代碼將能工作，因?yàn)樗灰蕾囉诰幾g器必須知道關(guān)于 lu 的類型參數(shù)的任何信息：

　　Listli = new ArrayList();

　　li.add(new Integer(42));

　　List lu = li;

　　lu.clear();

　　4.6 泛型方法

　　（在類型參數(shù) 一節(jié)中）您已經(jīng)看到，通過在類的定義中添加一個(gè)形式類型參數(shù)列表，可以將類泛型化。方法也可以被泛型化，不管它們定義在其中的類是不是泛型化的。

　　泛型類在多個(gè)方法簽名間實(shí)施類型約束。在 List中，類型參數(shù) V 出現(xiàn)在 get()、add()、contains() 等方法的簽名中。當(dāng)創(chuàng)建一個(gè) Map類型的變量時(shí)，您就在方法之間宣稱一個(gè)類型約束。您傳遞給 add() 的值將與 get() 返回的值的類型相同。

　　類似地，之所以聲明泛型方法，一般是因?yàn)槟胍谠摲椒ǖ亩鄠€(gè)參數(shù)之間宣稱一個(gè)類型約束。例如，下面代碼中的 ifThenElse() 方法，根據(jù)它的第一個(gè)參數(shù)的布爾值，它將返回第二個(gè)或第三個(gè)參數(shù)：

　　publicT ifThenElse(boolean b, T first, T second) {

　　return b ? first : second;

　　}

　　注意，您可以調(diào)用 ifThenElse()，而不用顯式地告訴編譯器，您想要 T 的什么值。編譯器不必顯式地被告知 T 將具有什么值；它只知道這些值都必須相同。編譯器允許您調(diào)用下面的代碼，因?yàn)榫幾g器可以使用類型推理來推斷出，替代 T 的 String 滿足所有的類型約束： String s = ifThenElse(b, "a", "b");

　　類似地，您可以調(diào)用：

　　Integer i = ifThenElse(b, new Integer(1), new Integer(2));

　　但是，編譯器不允許下面的代碼，因?yàn)闆]有類型會(huì)滿足所需的類型約束：

　　String s = ifThenElse(b, "pi", new Float(3.14));

　　為什么您選擇使用泛型方法，而不是將類型 T 添加到類定義呢？（至少）有兩種情況應(yīng)該這樣做：

　　當(dāng)泛型方法是靜態(tài)的時(shí)，這種情況下不能使用類類型參數(shù)。

　　當(dāng) T 上的類型約束對于方法真正是局部的時(shí)，這意味著沒有在相同類的另一個(gè)方法簽名中使用相同類型 T 的約束。通過使得泛型方法的類型參數(shù)對于方法是局部的，可以簡化封閉類型的簽名。

　　4.7 有限制類型

　　在前一屏泛型方法的例子中，類型參數(shù) V 是無約束的或無限制的類型。有時(shí)在還沒有完全指定類型參數(shù)時(shí)，需要對類型參數(shù)指定附加的約束。

　　考慮例子 Matrix 類，它使用類型參數(shù) V，該參數(shù)由 Number 類來限制：

　　public class Matrix{ ... }

　　編譯器允許您創(chuàng)建 Matrix或 Matrix類型的變量，但是如果您試圖定義

　　篇二：java泛型基礎(chǔ)知識總結(jié)

　　Java泛型

　　Java泛型是java1.5中引入的新特性，在此之前，java通過對類型Object的引用來實(shí)現(xiàn)參數(shù)類型的“任意化”，特點(diǎn)則是需要進(jìn)行顯示的強(qiáng)制類型轉(zhuǎn)換。（而這種顯示的`類型轉(zhuǎn)換可能是無法進(jìn)行的，是錯(cuò)誤的）但編譯器無法發(fā)現(xiàn)強(qiáng)制類型轉(zhuǎn)換可能引起的異常，異常只有在運(yùn)行時(shí)才能出現(xiàn)，成為了系統(tǒng)的安全隱患。----------------------------為啥要進(jìn)入泛型這個(gè)概念泛型的本質(zhì)是參數(shù)化類型，及所操作的數(shù)據(jù)類型被指定為一個(gè)參數(shù)，此參數(shù)類型可以用在類、接口、和方法的聲明及創(chuàng)建中，分別被稱為泛型類，泛型接口，及泛型方法。使用注意事項(xiàng)：

　　泛型的類型參數(shù)只能是類類型（包括自定義類），但是不能是簡單類型泛型類型參數(shù)可以是多個(gè)

　　泛型的參數(shù)類型還可以是通配符類型

　　沒有泛型的錯(cuò)誤：

　　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í)沒有被發(fā)現(xiàn)

　　}

　　有時(shí)候需要使泛型變量能使用任何的類型，此時(shí)可以使用通配符”？”否則可能需要編寫許多版本的重載函數(shù)，使用通配符，使方法printLsit（）可以接受各種類型的List對象，否則必須使用重載技術(shù)，

　　Public static void printList(Listlist)

　　{

　　//輸出集合中的元素

　　}

　　篇三：JAVA泛型的簡單實(shí)例

　　簡單普通類

　　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("設(shè)計(jì)者：");

　　Student s1 = new Student(123, "張三", "11計(jì)科");

　　Student s2 = new Student(124, "李四", "11計(jì)科");

　　Student s3 = new Student(125, "王五", "11計(jì)科");

　　Student dujingjing = new Student(20110105,"杜","11計(jì)科");

　　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);

　　}

　　簡單泛型實(shí)例

　　java中泛型定義

　　Java的泛型類就是一個(gè)用類型作為參數(shù)的類，即帶有參數(shù)化類型的類。就像我們定義類的成員方法一樣。大家很熟悉Java的成員方法形式是method(String str，int i)，方法中參數(shù)str、i的值是可變的。而泛型也是一樣的：class泛型類類名，這里的K和V就像方法中的參數(shù)str和i，也是可變的。

　　Class UseT{

　　Private T x;

　　Public SetX(T x){````````}

　　}

　　package test7;

　　泛型類：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("數(shù)據(jù)為：" + this.obj); }

　　}

　　主類：

　　public class test072 {

　　public static void main(String[] args) {

　　System.out.println("設(shè)計(jì)者:");

　　L2name = new L2("汽車"); name.showobj(name.getobj());

　　L2data = new L2(12); data.showobj(data.getobj());

　　}

　　簡單集合類

　　篇四：java泛型總結(jié)

　　泛型總結(jié)篇：

　　1）泛型參數(shù)只能是類類型

　　例如：List// 報(bào)錯(cuò)

　　List// 正確

　　2）泛型的類型參數(shù)可以有多個(gè)！

　　例如：Listlist = new

　　ArrayList();

　　3）泛型的參數(shù)類型可以使用extends，習(xí)慣稱“有界類型”，

　　例如：List，person為list的上界

　　4）泛型可以使用通配符類型！“？” 相當(dāng)于“Object”類型，（注意不可逆）例如：List //定義成這樣可以添加Object類型到List里面去 List

　　; //定義成這樣不可以添加String類型到List里面去 List; // 這樣就可以互等了！這樣還可以設(shè)定泛型的上限

　　5）帶泛型的類，構(gòu)造方法寫法不變，其后不可以加泛型！

　　例如：class Student{

　　public Student(){} // 構(gòu)造方法這樣寫就錯(cuò)了

　　}

　　6）List不是 List

　　的子類！，不可以把前者看成后者的子類，所以不

　　可以把前者的實(shí)例賦給后者

　　例如： ListSlist = new ArrayList();

　　Slist.add(new String("abc"));

　　List

　　Olist = new ArrayList

　　();

　　Olist.add("abc");

　　Olist = Slist; // 報(bào)錯(cuò)！

　　7）帶不同泛型參數(shù)的實(shí)例可以共享類的靜態(tài)方法和靜態(tài)變量，所以靜態(tài)方法和靜態(tài)變量

　　申明的時(shí)候不可以使用類型行參

　　例如：class Cup{

　　static T info; // 報(bào)錯(cuò)！

　　public static setInfo(T info){}； // 報(bào)錯(cuò)！

　　}

　　8）帶不同泛型參數(shù)的類是共享一個(gè)字節(jié)碼文件的！反編譯過后泛型參數(shù)就被擦除了

　　例如：ListSlist = new ArrayList();

　　Slist.add(new String("aaa"));

　　ListIlist = new ArrayList();

　　Ilist.add(new Integer(100));

　　System.out.println(Slist.getClass()==Ilist.getClass()); 結(jié)果為true；

　　9）當(dāng)使用定義了泛型參數(shù)的接口和父類的時(shí)候！就不能在帶參數(shù)了例如：class Sub extends Father{} // 錯(cuò)誤

　　10）

　　class T{}

　　public class typeTest extends T{}//報(bào)錯(cuò)

　　class T{}

　　public class typeTest extends T{} // 正確可使用String等基本封裝類型

　　class T{}

　　class Student{}

　　public class typeTest extends T{} // 這樣也正確

　　11）泛型方法，泛型方法的參數(shù)的作用域僅在本方法，要和方法帶泛型區(qū)分開！ Staticvoid test(ListS_list){} // 泛型參數(shù)要放在返回類型前

　　12）帶有泛型的代碼轉(zhuǎn)換成沒有泛型的代碼由javac完成，虛擬機(jī)不處理這些事情！

　　這種技術(shù)叫做 “擦除”；

　　例如：class Food{

　　T size;

　　public Food(T size){} //注意構(gòu)造方法不可以帶泛型參數(shù)！

　　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的類型 Food b = a; //把a(bǔ)對象賦給Food變量；泛型參數(shù)類型會(huì)丟失即擦除；

　　Number size1 = b.getSize(); // b只知道size的類型是Number // Integer in = b.getSize(); 這樣是編譯錯(cuò)誤的！

　　} }

　　篇五：Java泛型簡明教程

　　導(dǎo)讀：本文是從《Java Generics Quick Tutorial》這篇文章翻譯而來，譯文來自外刊IT評論《Java泛型簡明教程》。內(nèi)容如下：

　　泛型是Java SE 5.0中引入的一項(xiàng)特征，自從這項(xiàng)語言特征出現(xiàn)多年來，我相信，幾乎所有的Java程序員不僅聽說過，而且使用過它。關(guān)于Java泛型的教程，免費(fèi)的，不免費(fèi)的，有很多。我遇到的最好的教材有：

　　The Java Tutorial

　　Java Generics and Collections, by Maurice Naftalin and Philip Wadler

　　Effective Java中文版(第2版), by Joshua Bloch.

　　盡管有這么多豐富的資料，有時(shí)我感覺，有很多的程序員仍然不太明白Java泛型的功能和意義。這就是為什么我想使用一種最簡單的形式來總結(jié)一下程序員需要知道的關(guān)于Java泛型的最基本的知識。

　　Java泛型由來的動(dòng)機(jī)

　　理解Java泛型最簡單的方法是把它看成一種便捷語法，能節(jié)省你某些Java類型轉(zhuǎn)換(casting)上的操作：

　　1. Listbox = ...;

　　2. Apple apple = box.get(0);

　　上面的代碼自身已表達(dá)的很清楚：box是一個(gè)裝有Apple對象的List。get方法返回一個(gè)Apple對象實(shí)例，這個(gè)過程不需要進(jìn)行類型轉(zhuǎn)換。沒有泛型，上面的代碼需要寫成這樣：

　　1. List box = ...;

　　2. Apple apple = (Apple) box.get(0);

　　很明顯，泛型的主要好處就是讓編譯器保留參數(shù)的類型信息，執(zhí)行類型檢查，執(zhí)行類型轉(zhuǎn)換操作：編譯器保證了這些類型轉(zhuǎn)換的絕對無誤。

　　相對于依賴程序員來記住對象類型、執(zhí)行類型轉(zhuǎn)換——這會(huì)導(dǎo)致程序運(yùn)行時(shí)的失敗，很難調(diào)試和解決，而編譯器能夠幫助程序員在編譯時(shí)強(qiáng)制進(jìn)行大量的類型檢查，發(fā)現(xiàn)其中的錯(cuò)誤。泛型的構(gòu)成

　　由泛型的構(gòu)成引出了一個(gè)類型變量的概念。根據(jù)Java語言規(guī)范，類型變量是一種沒有限制的標(biāo)志符，產(chǎn)生于以下幾種情況：

　　泛型類聲明

　　泛型接口聲明

　　泛型方法聲明

　　泛型構(gòu)造器(constructor)聲明

　　泛型類和接口

　　如果一個(gè)類或接口上有一個(gè)或多個(gè)類型變量，那它就是泛型。類型變量由尖括號界定，放在類或接口名的后面：

　　1. public interface Listextends Collection{

　　3. ...

　　4. }

　　簡單的說，類型變量扮演的角色就如同一個(gè)參數(shù)，它提供給編譯器用來類型檢查的信息。 Java類庫里的很多類，例如整個(gè)Collection框架都做了泛型化的修改。例如，我們在上面的第一段代碼里用到的List接口就是一個(gè)泛型類。在那段代碼里，box是一個(gè)List對象，它是一個(gè)帶有一個(gè)Apple類型變量的List接口的類實(shí)現(xiàn)的實(shí)例。編譯器使用這個(gè)類型變量參數(shù)在get方法被調(diào)用、返回一個(gè)Apple對象時(shí)自動(dòng)對其進(jìn)行類型轉(zhuǎn)換。實(shí)際上，這新出現(xiàn)的泛型標(biāo)記，或者說這個(gè)List接口里的get方法是這樣的：

　　1. T get(int index);

　　get方法實(shí)際返回的是一個(gè)類型為T的對象，T是在List聲明中的類型變量。泛型方法和構(gòu)造器(Constructor)

　　非常的相似，如果方法和構(gòu)造器上聲明了一個(gè)或多個(gè)類型變量，它們也可以泛型化。

　　1. public staticT getFirst(Listlist)

　　這個(gè)方法將會(huì)接受一個(gè)List類型的參數(shù)，返回一個(gè)T類型的對象。

　　例子

　　你既可以使用Java類庫里提供的泛型類，也可以使用自己的泛型類。

　　類型安全的寫入數(shù)據(jù)…

　　下面的這段代碼是個(gè)例子，我們創(chuàng)建了一個(gè)List實(shí)例，然后裝入一些數(shù)據(jù)：

　　1. Liststr = new ArrayList();

　　3. str.add("Hello ");

　　5. str.add("World.");

　　如果我們試圖在List裝入另外一種對象，編譯器就會(huì)提示錯(cuò)誤：

　　1. str.add(1); //不能編譯

　　類型安全的讀取數(shù)據(jù)…

　　當(dāng)我們在使用List對象時(shí)，它總能保證我們得到的是一個(gè)String對象：

　　1. String myString = str.get(0);

　　遍歷

　　類庫中的很多類，諸如Iterator，功能都有所增強(qiáng)，被泛型化。List接口里的 iterator()方法現(xiàn)在返回的是Iterator，由它的T next()方法返回的對象不需要再進(jìn)行類型轉(zhuǎn)換，你直接得到正確的類型。

　　1. for (Iteratoriter = str.iterator(); iter.hasNext();){

　　3. String s = iter.next();

　　5. System.out.print(s);

　　7. }

　　使用foreach

　　“for each”語法同樣受益于泛型。前面的代碼可以寫出這樣：

　　1. for (String s: str){

　　3. System.out.print(s);

　　5. }

　　這樣既容易閱讀也容易維護(hù)。

　　自動(dòng)封裝(Autoboxing)和自動(dòng)拆封(Autounboxing)

　　在使用Java泛型時(shí)，autoboxing/autounboxing這兩個(gè)特征會(huì)被自動(dòng)的用到，就像下面的這段代碼：

　　1. Listints = new ArrayList();

　　3. ints.add(0);

　　5. ints.add(1);

　　10.int sum = 0;

　　11.

　　12.for (int i : ints){

　　13.

　　14.sum += i;

　　15.

　　16.}

　　然而，你要明白的一點(diǎn)是，封裝和解封會(huì)帶來性能上的損失，所有，通用要謹(jǐn)慎的使用。子類型

　　在Java中，跟其它具有面向?qū)ο箢愋偷恼Z言一樣，類型的層級可以被設(shè)計(jì)成這樣：

　　在Java中，類型T的子類型既可以是類型T的一個(gè)擴(kuò)展，也可以是類型T的一個(gè)直接或非直接實(shí)現(xiàn)(如果T是一個(gè)接口的話)。因?yàn)椤俺蔀槟愁愋偷淖宇愋汀笔且粋€(gè)具有傳遞性質(zhì)的關(guān)系，如果類型A是B的一個(gè)子類型，B是C的子類型，那么A也是C的子類型。在上面的圖中： FujiApple(富士蘋果)是Apple的子類型

　　Apple是Fruit(水果)的子類型

　　FujiApple(富士蘋果)是Fruit(水果)的子類型

　　所有Java類型都是Object類型的子類型。

　　B類型的任何一個(gè)子類型A都可以被賦給一個(gè)類型B的聲明：

　　1. Apple a = ...;

　　2. Fruit f = a;

　　泛型類型的子類型

　　如果一個(gè)Apple對象的實(shí)例可以被賦給一個(gè)Fruit對象的聲明，就像上面看到的，那么，List和 a List之間又是個(gè)什么關(guān)系呢？更通用些，如果類型A是類型B的子類型，那C 和 C之間是什么關(guān)系？

　　答案會(huì)出乎你的意料：沒有任何關(guān)系。用更通俗的話，泛型類型跟其是否子類型沒有任何關(guān)系。

【Java泛型總結(jié)報(bào)告精選】相關(guān)文章：

實(shí)習(xí)總結(jié)報(bào)告（精選9篇）12-29

雇傭型合同04-25