Java泛型總結(jié)報告精選
篇一:Java泛型總結(jié)
1. 什么是泛型?
泛型(Generic type 或者 generics)是對 Java 語言的類型系統(tǒng)的一種擴展,以支持創(chuàng)建可以按類型進行參數(shù)化的類。可以把類型參數(shù)看作是使用參數(shù)化類型時指定的類型的一個占位符,就像方法的形式參數(shù)是運行時傳遞的值的占位符一樣。
可以在集合框架(Collection framework)中看到泛型的動機。例如,Map 類允許您向一個 Map 添加任意類的對象,即使最常見的情況是在給定映射(map)中保存某個特定類型(比如 String)的對象。
因為 Map.get() 被定義為返回 Object,所以一般必須將 Map.get() 的結(jié)果強制類型轉(zhuǎn)換為期望的類型,如下面的代碼所示:
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("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 程序的類型安全。通過知道使用泛型定義的變量的類型限制,編譯器可以在一個高得多的程度上驗證類型假設(shè)。沒有泛型,這些假設(shè)就只存在于程序員的頭腦中(或者如果幸運的話,還存在于代碼注釋中)。
Java 程序中的一種流行技術(shù)是定義這樣的集合,即它的元素或鍵是公共類型的,比如“String 列表”或者“String 到 String 的映射”。通過在變量聲明中捕獲這一附加的類型信息,泛型允許編譯器實施這些附加的類型約束。類型錯誤現(xiàn)在就可以在編譯時被捕獲了,而不是在運行時當(dāng)作 ClassCastException 展示出來。將類型檢查從運行時挪到編譯時有助于您更容易找到錯誤,并可提高程序的可靠性。
消除強制類型轉(zhuǎn)換。 泛型的一個附帶好處是,消除源代碼中的許多強制類型轉(zhuǎn)換。這使得代碼更加可讀,并且減少了出錯機會。
盡管減少強制類型轉(zhuǎn)換可以降低使用泛型類的代碼的羅嗦程度,但是聲明泛型變量會帶來相應(yīng)的羅嗦。比較下面兩個代碼例子。
該代碼不使用泛型:
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);
在簡單的程序中使用一次泛型變量不會降低羅嗦程度。但是對于多次使用泛型變量的大型程序來說,則可以累積起來降低羅嗦程度。
潛在的性能收益。 泛型為較大的優(yōu)化帶來可能。在泛型的初始實現(xiàn)中,編譯器將強制類型轉(zhuǎn)換(沒有泛型的話,程序員會指定這些強制類型轉(zhuǎn)換)插入生成的字節(jié)碼中。但是更多類型信息可用于編譯器這一事實,為未來版本的 JVM 的優(yōu)化帶來可能。
由于泛型的實現(xiàn)方式,支持泛型(幾乎)不需要 JVM 或類文件更改。所有工作都在編譯器中完成,編譯器生成類似于沒有泛型(和強制類型轉(zhuǎn)換)時所寫的代碼,只是更能確保類型安全而已。
3. 泛型用法的例子
泛型的許多最佳例子都來自集合框架,因為泛型讓您在保存在集合中的元素上指定類型約束?紤]這個使用 Map 類的例子,其中涉及一定程度的優(yōu)化,即 Map.get() 返回的結(jié)果將確實是一個 String:
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("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();
m.put("key", "blarg");
String s = m.get("key");
當(dāng)使用 Map 的泛型化版本時,您不再需要將 Map.get() 的結(jié)果強制類型轉(zhuǎn)換為 String,因為編譯器知道 get() 將返回一個 String。
在使用泛型的版本中并沒有減少鍵盤錄入;實際上,比使用強制類型轉(zhuǎn)換的版本需要做更多鍵入。使用泛型只是帶來了附加的類型安全。因為編譯器知道關(guān)于您將放進 Map 中的鍵和值的類型的更多信息,所以類型檢查從執(zhí)行時挪到了編譯時,這會提高可靠性并加快開發(fā)速度。
向后兼容
在 Java 語言中引入泛型的一個重要目標就是維護向后兼容。盡管 JDK 5.0 的標準類庫中的許多類,比如集合框架,都已經(jīng)泛型化了,但是使用集合類(比如 HashMap 和 ArrayList)的現(xiàn)有代碼將繼續(xù)不加修改地在 JDK 5.0 中工作。當(dāng)然,沒有利用泛型的現(xiàn)有代碼將不會贏得泛型的類型安全好處。
4. 泛型基礎(chǔ)
4.1 類型參數(shù)
在定義泛型類或聲明泛型類的變量時,使用尖括號來指定形式類型參數(shù)。形式類型參數(shù)與實際類型參數(shù)之間的關(guān)系類似于形式方法參數(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 接口是由兩個類型參數(shù)化的,這兩個類型是鍵類型 K 和值類型 V。(不使用泛型)將會接受或返回 Object 的方法現(xiàn)在在它們的方法簽名中使用 K 或 V,指示附加的類型約束位于 Map 的規(guī)格說明之下。
當(dāng)聲明或者實例化一個泛型的對象時,必須指定類型參數(shù)的值:
Mapmap = new Ha
shMap();
注意,在本例中,必須指定兩次類型參數(shù)。一次是在聲明變量 map 的類型時,另一次是在選擇 HashMap 類的參數(shù)化以便可以實例化正確類型的一個實例時。
編譯器在遇到一個 Map類型的變量時,知道 K 和 V 現(xiàn)在被綁定為 String,因此它知道在這樣的變量上調(diào)用 Map.get() 將會得到 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é)變的
關(guān)于泛型的混淆,一個常見的來源就是假設(shè)它們像數(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,下面的代碼就會違背泛型應(yīng)該提供的類型安全:
ListintList = new ArrayList();
ListnumberList = intList; // invalid
numberList.add(new Float(3.1415));
因為 intList 和 numberList 都是有別名的,如果允許的話,上面的代碼就會讓您將不是 Integers 的東西放進 intList 中。但是,正如下一屏將會看到的,您有一個更加靈活的方式來定義泛型。
4.4 類型通配符
假設(shè)您具有該方法:
void printList(List l) {
for (Object o : l)
System.out.println(o);
}
上面的代碼在 JDK 5.0 上編譯通過,但是如果試圖用 List調(diào)用它,則會得到警告。出現(xiàn)警告是因為,您將泛型(List)傳遞給一個只承諾將它當(dāng)作 List(所謂的原始類型)的方法,這將破壞使用泛型的類型安全。
如果試圖編寫像下面這樣的方法,那么將會怎么樣?
void printList(List
l) {
for (Object o : l)
System.out.println(o);
}
它仍然不會通過編譯,因為一個 List不是 一個 List
。ㄕ缜耙黄 泛型不是協(xié)變的 中所學(xué)的)。這才真正煩人 —— 現(xiàn)在您的泛型版本還沒有普通的非泛型版本有用!
解決方案是使用類型通配符:
void printList(List l) {
for (Object o : l)
System.out.println(o);
}
上面代碼中的問號是一個類型通配符。它讀作“問號”。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,編譯器一點都不知道 List 的類型參數(shù)的值。但是編譯器比較聰明,它可以做一些類型推理。在本例中,它推斷未知的類型參數(shù)必須擴展 Object。(這個特定的推理沒有太大的跳躍,但是編譯器可以作出一些非常令人佩服的類型推理,后面就會看到(在底層細節(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ù)作出足夠嚴密的推理,以確定將 Integer 傳遞給 List.add() 是類型安全的。所以編譯器將不允許您這么做。
以免您仍然認為編譯器知道哪些方法更改列表的內(nèi)容哪些不更改列表內(nèi)容,請注意下面的代碼將能工作,因為它不依賴于編譯器必須知道關(guān)于 lu 的類型參數(shù)的任何信息:
Listli = new ArrayList();
li.add(new Integer(42));
List lu = li;
lu.clear();
4.6 泛型方法
。ㄔ 類型參數(shù) 一節(jié)中)您已經(jīng)看到,通過在類的定義中添加一個形式類型參數(shù)列表,可以將類泛型化。方法也可以被泛型化,不管它們定義在其中的類是不是泛型化的。
泛型類在多個方法簽名間實施類型約束。在 List中,類型參數(shù) V 出現(xiàn)在 get()、add()、contains() 等方法的簽名中。當(dāng)創(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 添加到類定義呢?(至少)有兩種情況應(yīng)該這樣做:
當(dāng)泛型方法是靜態(tài)的時,這種情況下不能使用類類型參數(shù)。
當(dāng) T 上的類型約束對于方法真正是局部的時,這意味著沒有在相同類的另一個方法簽名中使用相同類型 T 的約束。通過使得泛型方法的類型參數(shù)對于方法是局部的,可以簡化封閉類型的簽名。
4.7 有限制類型
在前一屏 泛型方法 的例子中,類型參數(shù) V 是無約束的或無限制的類型。有時在還沒有完全指定類型參數(shù)時,需要對類型參數(shù)指定附加的約束。
考慮例子 Matrix 類,它使用類型參數(shù) V,該參數(shù)由 Number 類來限制:
public class Matrix{ ... }
編譯器允許您創(chuàng)建 Matrix或 Matrix類型的變量,但是如果您試圖定義
篇二:java泛型基礎(chǔ)知識總結(jié)
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 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異常,而且編譯時沒有被發(fā)現(xiàn)
}
有時候需要使泛型變量能使用任何的類型,此時可以使用通配符”?”否則可能需要編寫許多版本的重載函數(shù),使用通配符,使方法printLsit()可以接受各種類型的List對象,否則必須使用重載技術(shù),
Public static void printList(Listlist)
{
//輸出集合中的元素
}
篇三:JAVA泛型的簡單實例
簡單普通類
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è)計者:");
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);
}
}
}
簡單泛型實例
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)
{
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è)計者:");
L2name = new L2("汽車"); name.showobj(name.getobj());
L2data = new L2(12); data.showobj(data.getobj());
}
}
簡單集合類
篇四:java泛型總結(jié)
泛型總結(jié)篇:
1)泛型參數(shù)只能是類類型
例如:List// 報錯
List// 正確
2)泛型的類型參數(shù)可以有多個!
例如: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)造方法這樣寫就錯了
}
6)List不是 List
的子類!,不可以把前者看成后者的子類,所以不
可以把前者的實例賦給后者
例如: ListSlist = new ArrayList();
Slist.add(new String("abc"));
List
Olist = new ArrayList
();
Olist.add("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();
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ù)了 例如: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完成,虛擬機不處理這些事情!
這種技術(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對象賦給Food變量;泛型參數(shù)類型會丟失 即擦除;
Number size1 = b.getSize(); // b只知道size的類型是Number // Integer in = b.getSize(); 這樣是編譯錯誤的!
} }
篇五:Java泛型簡明教程
導(dǎo)讀:本文是從《Java Generics Quick Tutorial》這篇文章翻譯而來,譯文來自外刊IT評論《Java泛型簡明教程》。內(nèi)容如下:
泛型是Java SE 5.0中引入的一項特征,自從這項語言特征出現(xiàn)多年來,我相信,幾乎所有的Java程序員不僅聽說過,而且使用過它。關(guān)于Java泛型的教程,免費的,不免費的,有很多。我遇到的最好的教材有:
The Java Tutorial
Java Generics and Collections, by Maurice Naftalin and Philip Wadler
Effective Java中文版(第2版), by Joshua Bloch.
盡管有這么多豐富的資料,有時我感覺,有很多的程序員仍然不太明白Java泛型的功能和意義。這就是為什么我想使用一種最簡單的形式來總結(jié)一下程序員需要知道的關(guān)于Java泛型的最基本的知識。
Java泛型由來的動機
理解Java泛型最簡單的方法是把它看成一種便捷語法,能節(jié)省你某些Java類型轉(zhuǎn)換(casting)上的操作:
1. Listbox = ...;
2. Apple apple = box.get(0);
上面的代碼自身已表達的很清楚:box是一個裝有Apple對象的List。get方法返回一個Apple對象實例,這個過程不需要進行類型轉(zhuǎn)換。沒有泛型,上面的代碼需要寫成這樣:
1. List box = ...;
2. Apple apple = (Apple) box.get(0);
很明顯,泛型的主要好處就是讓編譯器保留參數(shù)的類型信息,執(zhí)行類型檢查,執(zhí)行類型轉(zhuǎn)換操作:編譯器保證了這些類型轉(zhuǎn)換的絕對無誤。
相對于依賴程序員來記住對象類型、執(zhí)行類型轉(zhuǎn)換——這會導(dǎo)致程序運行時的失敗,很難調(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. str.add("Hello ");
4.
5. str.add("World.");
如果我們試圖在List裝入另外一種對象,編譯器就會提示錯誤:
1. str.add(1); //不能編譯
類型安全的讀取數(shù)據(jù)…
當(dāng)我們在使用List對象時,它總能保證我們得到的是一個String對象:
1. String myString = str.get(0);
遍歷
類庫中的很多類,諸如Iterator,功能都有所增強,被泛型化。List接口里的 iterator()方法現(xiàn)在返回的是Iterator,由它的T next()方法返回的對象不需要再進行類型轉(zhuǎn)換,你直接得到正確的類型。
1. for (Iteratoriter = str.iterator(); iter.hasNext();){
2.
3. String s = iter.next();
4.
5. System.out.print(s);
6.
7. }
使用foreach
“for each”語法同樣受益于泛型。前面的代碼可以寫出這樣:
1. for (String s: str){
2.
3. System.out.print(s);
4.
5. }
這樣既容易閱讀也容易維護。
自動封裝(Autoboxing)和自動拆封(Autounboxing)
在使用Java泛型時,autoboxing/autounboxing這兩個特征會被自動的用到,就像下面的這段代碼:
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.}
然而,你要明白的一點是,封裝和解封會帶來性能上的損失,所有,通用要謹慎的使用。 子類型
在Java中,跟其它具有面向?qū)ο箢愋偷恼Z言一樣,類型的層級可以被設(shè)計成這樣:
在Java中,類型T的子類型既可以是類型T的一個擴展,也可以是類型T的一個直接或非直接實現(xiàn)(如果T是一個接口的話)。因為“成為某類型的子類型”是一個具有傳遞性質(zhì)的關(guān)系,如果類型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之間又是個什么關(guān)系呢?更通用些,如果類型A是類型B的子類型,那C 和 C之間是什么關(guān)系?
答案會出乎你的意料:沒有任何關(guān)系。用更通俗的話,泛型類型跟其是否子類型沒有任何關(guān)系。
【Java泛型總結(jié)報告精選】相關(guān)文章:
雇傭型合同04-25
季度個人總結(jié)報告01-19
員工述職總結(jié)報告10-11
會議總結(jié)報告范文01-12
月度會議總結(jié)報告08-18
商務(wù)公函談判型公函12-05
會議的總結(jié)報告范文01-09
會議組織總結(jié)報告結(jié)尾01-28
務(wù)虛會會議總結(jié)報告09-06