在日常的學習,、工作,、生活中，肯定對各類范文都很熟悉吧,。范文怎么寫才能發(fā)揮它最大的作用呢？以下是小編為大家收集的優(yōu)秀范文,，歡迎大家分享閱讀,。

java泛型實現(xiàn)篇一

package test7;

import ist;

class student

{

int number;

string name;

string cla;

public int getnumber()

{

return number;

}

public void setnumber(int number)

{

thi = number;

}

public string getname()

{

return name;

}

public void setname(string name)

{

= name;

}

public string getcla()

{

return cla;

}

public void setcla(string cla)

{

thi = cla;

}

public student(){}

public student(int number,string name,string cla)

{

thi = number;

= name;

thi = cla;

}

}

public class test071 {

public static void main(string[] args) {

n("設計者：");

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

(s1);

(s2);

(s3);

(dujingjing);

for(int i = 0;i<();i++)

{

student s = (student)(i);

n("學號：" + + " 姓名：" ++ " 班級：" +);

}

}

}

簡單泛型實例

java中泛型定義

java的泛型類就是一個用類型作為參數(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)

{

= obj;

}

public t getobj()

{

return ;

}

public void setobj(t obj)

{

= obj;

}

public void showobj(t obj)

{

n("數(shù)據(jù)為：" + ); }

}

主類：

public class test072 {

public static void main(string[] args) {

n("設計者:");

l2name = new l2("汽車"); j(());

l2data = new l2(12); j(());

}

}

簡單集合類

java泛型實現(xiàn)篇二

1. 什么是泛型,？

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

可以在集合框架（collection framework）中看到泛型的動機,。例如，map 類允許您向一個 map 添加任意類的對象,，即使最常見的情況是在給定映射（map）中保存某個特定類型（比如 string）的對象,。

因為 () 被定義為返回 object,，所以一般必須將 () 的結(jié)果強制類型轉(zhuǎn)換為期望的類型,，如下面的代碼所示：

map m = new hashmap();

("key", "blarg");

string s = (string) ("key");

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

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

2. 泛型的好處

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

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

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

消除強制類型轉(zhuǎn)換。 泛型的一個附帶好處是,，消除源代碼中的許多強制類型轉(zhuǎn)換,。這使得代碼更加可讀，并且減少了出錯機會,。

盡管減少強制類型轉(zhuǎn)換可以降低使用泛型類的代碼的羅嗦程度,，但是聲明泛型變量會帶來相應的羅嗦。比較下面兩個代碼例子,。

該代碼不使用泛型：

list li = new arraylist();

(new integer(3));

integer i = (integer) (0);

該代碼使用泛型：

listli = new arraylist();

(new integer(3));

integer i = (0);

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

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

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

3. 泛型用法的例子

泛型的許多最佳例子都來自集合框架,，因為泛型讓您在保存在集合中的元素上指定類型約束,。考慮這個使用 map 類的例子,，其中涉及一定程度的優(yōu)化,，即 () 返回的結(jié)果將確實是一個 string：

map m = new hashmap();

("key", "blarg");

string s = (string) ("key");

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

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

public interface map{

public void put(k key, v value);

public v get(k key);

}

注意該接口的兩個附加物：

類型參數(shù) k 和 v 在類級別的規(guī)格說明,，表示在聲明一個 map 類型的變量時指定的類型的占位符,。

在 get()、put() 和其他方法的方法簽名中使用的 k 和 v,。

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

mapm = new hashmap();

("key", "blarg");

string s = ("key");

當使用 map 的泛型化版本時,，您不再需要將 () 的結(jié)果強制類型轉(zhuǎn)換為 string,，因為編譯器知道 get() 將返回一個 string。

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

向后兼容

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

4. 泛型基礎

4.1 類型參數(shù)

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

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

public interface map{

public void put(k key, v value);

public v get(k key);

}

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

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

mapmap = new ha

shmap();

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

編譯器在遇到一個 map類型的變量時,，知道 k 和 v 現(xiàn)在被綁定為 string，因此它知道在這樣的變量上調(diào)用 () 將會得到 string 類型,。

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

4.2 命名類型參數(shù)

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

k —— 鍵，比如映射的鍵,。

v —— 值,，比如 list 和 set 的內(nèi)容，或者 map 中的值,。

e —— 異常類,。

t —— 泛型,。

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

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

不是 list的父類型。

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

integer[] intarray = new integer[10];

number[] numberarray = intarray;

上面的代碼是有效的，因為一個 integer 是一個 number,，因而一個 integer 數(shù)組是 一個 number 數(shù)組,。但是對于泛型來說則不然。下面的代碼是無效的：

listintlist = new arraylist();

listnumberlist = intlist; // invalid

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

listintlist = new arraylist();

listnumberlist = intlist; // invalid

(new float(3.1415));

因為 intlist 和 numberlist 都是有別名的，如果允許的話,，上面的代碼就會讓您將不是 integers 的東西放進 intlist 中,。但是，正如下一屏將會看到的,，您有一個更加靈活的方式來定義泛型,。

4.4 類型通配符

假設您具有該方法：

void printlist(list l) {

for (object o : l)

n(o);

}

上面的代碼在 jdk 5.0 上編譯通過，但是如果試圖用 list調(diào)用它,，則會得到警告,。出現(xiàn)警告是因為，您將泛型（list）傳遞給一個只承諾將它當作 list（所謂的原始類型）的方法,，這將破壞使用泛型的類型安全,。

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

void printlist(list

l) {

for (object o : l)

n(o);

}

它仍然不會通過編譯,，因為一個 list不是 一個 list

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

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

void printlist(list l) {

for (object o : l)

n(o);

}

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

,、list或 list<list

> 傳遞給 printlist()。

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

listli = new arraylist();

(new integer(42));

list lu = li;

n((0));

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

listli = new arraylist();

(new integer(42));

list lu = li;

(new integer(43)); // error

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

以免您仍然認為編譯器知道哪些方法更改列表的內(nèi)容哪些不更改列表內(nèi)容,，請注意下面的代碼將能工作,，因為它不依賴于編譯器必須知道關于 lu 的類型參數(shù)的任何信息：

listli = new arraylist();

(new integer(42));

list lu = li;

();

4.6 泛型方法

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

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

類似地,，之所以聲明泛型方法,，一般是因為您想要在該方法的多個參數(shù)之間宣稱一個類型約束。例如,，下面代碼中的 ifthenelse() 方法,，根據(jù)它的第一個參數(shù)的布爾值，它將返回第二個或第三個參數(shù)：

publict ifthenelse(boolean b, t first, t second) {

return b ? first : second;

}

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

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

integer i = ifthenelse(b, new integer(1), new integer(2));

但是,，編譯器不允許下面的代碼,，因為沒有類型會滿足所需的類型約束：

string s = ifthenelse(b, "pi", new float(3.14));

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

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

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

4.7 有限制類型

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

考慮例子 matrix 類，它使用類型參數(shù) v,，該參數(shù)由 number 類來限制：

public class matrix{ ... }

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

java泛型實現(xiàn)篇三

java泛型

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

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

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

沒有泛型的錯誤：

import .*;

public class nogenerictypedemo{

public static void main(string[] args)

{

list names=new arraylist();

("張桑拿");

(new integer(2);

string namefirst=(string)(0);

string namesecond=(string)(1);//astexception異常,，而且編譯時沒有被發(fā)現(xiàn)

}

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

public static void printlist(listlist)

{

//輸出集合中的元素

}

java泛型實現(xiàn)篇四

泛型總結(jié)篇：

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

例如：list// 報錯

list// 正確

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

例如：listlist = new

arraylist();

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

例如：list,，person為list的上界

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

; //定義成這樣不可以添加string類型到list里面去 list; // 這樣就可以互等了！這樣還可以設定泛型的上限

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

例如：class student{

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

}

6）list不是 list

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

可以把前者的實例賦給后者

例如： listslist = new arraylist();

(new string("abc"));

list

olist = new arraylist

();

("abc");

olist = slist; // 報錯,！

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

申明的時候不可以使用類型行參

例如：class cup{

static t info; // 報錯！

public static setinfo(t info){},； // 報錯！

}

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

例如：listslist = new arraylist();

(new string("aaa"));

listilist = new arraylist();

(new integer(100));

n(ss()==ss()); 結(jié)果為true,；

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

10）

class t{}

public class typetest extends t{}//報錯

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完成，虛擬機不處理這些事情,！

這種技術叫做 “擦除”,；

例如：class food{

t size;

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

public void setsize(){ = size; }

public t getsize(){ return ;}

}

public class test{

public static void main(string arg[]){

fooda = new food(6);

ingeger as = e(); // 返回的是integer的類型 food b = a; //把a對象賦給food變量,；泛型參數(shù)類型會丟失 即擦除,；

number size1 = e(); // b只知道size的類型是number // integer in = e(); 這樣是編譯錯誤的！

} }

java泛型實現(xiàn)篇五

導讀：本文是從《java generics quick tutorial》這篇文章翻譯而來,，譯文來自外刊it評論《java泛型簡明教程》,。內(nèi)容如下：

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

the java tutorial

java generics and collections, by maurice naftalin and philip wadler

effective java中文版(第2版), by joshua bloch.

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

java泛型由來的動機

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

1. listbox = ...;

2. apple apple = (0);

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

1. list box = ...;

2. apple apple = (apple) (0);

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

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

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

泛型類聲明

泛型接口聲明

泛型方法聲明

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

泛型類和接口

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

1. public interface listextends collection{

2.

3. ...

4. }

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

1. t get(int index);

get方法實際返回的是一個類型為t的對象,，t是在list聲明中的類型變量,。 泛型方法和構(gòu)造器(constructor)

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

1. public statict getfirst(listlist)

這個方法將會接受一個list類型的參數(shù)，返回一個t類型的對象,。

例子

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

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

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

1. liststr = new arraylist();

2.

3. ("hello ");

4.

5. ("world.");

如果我們試圖在list裝入另外一種對象，編譯器就會提示錯誤：

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

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

當我們在使用list對象時,，它總能保證我們得到的是一個string對象：

1. string mystring = (0);

遍歷

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

1. for (iteratoriter = or(); t();){

2.

3. string s = ();

4.

5. (s);

6.

7. }

使用foreach

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

1. for (string s: str){

2.

3. (s);

4.

5. }

這樣既容易閱讀也容易維護。

自動封裝(autoboxing)和自動拆封(autounboxing)

在使用java泛型時,，autoboxing/autounboxing這兩個特征會被自動的用到，就像下面的這段代碼：

1. listints = new arraylist();

2.

3. (0);

4.

5. (1);

6.

7.

8.

9.

sum = 0;

11.

(int i : ints){

13.

+= i;

15.

16.}

然而,，你要明白的一點是,，封裝和解封會帶來性能上的損失，所有,，通用要謹慎的使用,。 子類型

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

在java中,，類型t的子類型既可以是類型t的一個擴展，也可以是類型t的一個直接或非直接實現(xiàn)(如果t是一個接口的話),。因為“成為某類型的子類型”是一個具有傳遞性質(zhì)的關系,，如果類型a是b的一個子類型，b是c的子類型,，那么a也是c的子類型,。在上面的圖中： fujiapple(富士蘋果)是apple的子類型

apple是fruit(水果)的子類型

fujiapple(富士蘋果)是fruit(水果)的子類型

所有java類型都是object類型的子類型。

b類型的任何一個子類型a都可以被賦給一個類型b的聲明：

1. apple a = ...;

2. fruit f = a;

泛型類型的子類型

如果一個apple對象的實例可以被賦給一個fruit對象的聲明,，就像上面看到的,，那么，list和 a list之間又是個什么關系呢,？更通用些,，如果類型a是類型b的子類型，那c 和 c

答案會出乎你的意料：沒有任何關系,。用更通俗的話,，泛型類型跟其是否子類型沒有任何關系。