java基礎之內部類和泛型,java泛型類和泛型方法

本文目錄一覽：

• 1、java基礎都包括什麼呀？
• 2、java泛型與內部類的三行代碼
• 3、java中什麼叫泛型？
• 4、要學習JAVA，要掌握哪些基礎知識？
• 5、java中什麼叫泛型??
• 6、Java基礎知識總結：什麼時候用泛型類

java基礎都包括什麼呀？

java語法基礎

1，關鍵字：其實就是某種語言賦予了特殊含義的單詞。

保留字：其實就是還沒有賦予特殊含義，但是準備日後要使用過的單詞。

2，標示符：其實就是在程序中自定義的名詞。比如類名，變量名，函數名。包含 0-9、a-z、$、_ ；

注意：

1），數字不可以開頭。

2），不可以使用關鍵字。

3，常量：是在程序中的不會變化的數據。

4，變量：其實就是內存中的一個存儲空間，用於存儲常量數據。

作用：方便於運算。因為有些數據不確定。所以確定該數據的名詞和存儲空間。

特點：變量空間可以重複使用。

什麼時候定義變量？只要是數據不確定的時候，就定義變量。

變量空間的開闢需要什麼要素呢？

1，這個空間要存儲什麼數據？數據類型。

2，這個空間叫什麼名字啊？變量名稱。

3，這個空間的第一次的數據是什麼？ 變量的初始化值。

變量的作用域和生存期:

變量的作用域：

作用域從變量定義的位置開始，到該變量所在的那對大括號結束；

生命周期：

變量從定義的位置開始就在內存中活了；

變量到達它所在的作用域的時候就在內存中消失了；

數據類型：

1）：基本數據類型：byte、short、int、long、float、double、char、boolean

2）：引用數據類型: 數組、類、接口。

級別從低到高為：byte,char,short(這三個平級)–int–float–long–double

自動類型轉換：從低級別到高級別，系統自動轉的；

強制類型轉換：什麼情況下使用?把一個高級別的數賦給一個別該數的級別低的變量；

運算符號：

1）、算術運算符。

+ – * / % %:任何整數模2不是0就是1，所以只要改變被模數就可以實現開關運算。

+:連接符。

++,–

2）、賦值運算符。

= += -= *= /= %=

3）、比較運算符。

特點：該運算符的特點是：運算完的結果，要麼是true，要麼是false。

4）、邏輯運算符。

| ^ ! ||

邏輯運算符除了! 外都是用於連接兩個boolean類型表達式。

: 只有兩邊都為true結果是true。否則就是false。

|:只要兩邊都為false結果是false，否則就是true

^:異或：和或有點不一樣。

兩邊結果一樣，就為false。

兩邊結果不一樣，就為true.

和 區別： ：無論左邊結果是什麼，右邊都參與運算。

:短路與，如果左邊為false，那麼右邊不參數與運算。

| 和|| 區別：|：兩邊都運算。

||：短路或，如果左邊為true，那麼右邊不參與運算。

5）、位運算符:用於操作二進制位的運算符。

| ^

(無符號右移)

練習：對兩個變量的數據進行互換。不需要第三方變量。

int a = 3,b = 5;–b = 3,a = 5;

a = a + b; a =8;

b = a – b; b =3;c

a = a – b; a =5;

a = a ^ b;//

b = a ^ b;//b= a ^ b ^ b = a

a = a ^ b;//a= a ^ b ^ a = b;

練習：高效的算出 2*8 —————— 位移運算的考驗，java基礎面試中它的曝光率不低哦

5，語句。

If switch do while while for

這些語句什麼時候用？

1）、當判斷固定個數的值的時候，可以使用if，也可以使用switch。

但是建議使用switch，效率相對較高。

switch(變量){

case 值:要執行的語句;break;

…

default:要執行的語句;

}

工作原理：用小括號中的變量的值依次和case後面的值進行對比，和哪個case後面的值相同了

就執行哪個case後面的語句，如果沒有相同的則執行default後面的語句；

細節：1）：break是可以省略的，如果省略了就一直執行到遇到break為止；

2）：switch 後面的小括號中的變量應該是byte,char,short,int四種類型中的一種；

3）：default可以寫在switch結構中的任意位置；如果將default語句放在了第一行，則不管expression與case中的value是否匹配，程序會從default開始執行直到第一個break出現。

2）、當判斷數據範圍，獲取判斷運算結果boolean類型時，需要使用if。

3）、當某些語句需要執行很多次時，就用循環結構。

while和for可以進行互換。

區別在於：如果需要定義變量控制循環次數。建議使用for。因為for循環完畢，變量在內存中釋放。

break:作用於switch ，和循環語句，用於跳出，或者稱為結束。

break語句單獨存在時，下面不要定義其他語句，因為執行不到，編譯會失敗。當循環嵌套時，break只跳出當前所在循環。要跳出嵌套中的外部循環，只要給循環起名字即可，這個名字稱之為標號。

代碼片段：

z: //for循環標號

for(int x=0;x3;x++){

for(int y=0;y2;y++){

//不帶標號的就是結束整個循環體的作用，在那個循環內部就結束哪個循環

if(x==1)break;

//帶標號跳過break後面的語句，回到標號位置的循環，繼續該循環下次的條件判斷，

//已決定是否執行該循環體

if(x==2y==1)break z;

}

}

continue:只作用於循環結構，繼續循環用的。

作用：結束本次循環，繼續下次循環。該語句單獨存在時，下面不可以定義語句，執行不到。

6，函 數：為了提高代碼的復用性，可以將其定義成一個單獨的功能，該功能的體現就是java中的函數。函數就是體現之一。

java中的函數的定義格式：

修飾符 返回值類型 函數名(參數類型 形式參數1，參數類型 形式參數1，…){

執行語句；

return 返回值；

}

當函數沒有具體的返回值時，返回的返回值類型用void關鍵字表示。

如果函數的返回值類型是void時，return語句可以省略不寫的，系統會幫你自動加上。

return的作用：結束函數。結束功能。

如何定義一個函數？

函數其實就是一個功能，定義函數就是實現功能，通過兩個明確來完成：

1）、明確該功能的運算完的結果，其實是在明確這個函數的返回值類型。

2）、在實現該功能的過程中是否有未知內容參與了運算，其實就是在明確這個函數的參數列表(參數類型參數個數)。

函數的作用：

1）、用於定義功能。

2）、用於封裝代碼提高代碼的復用性。

注意：函數中只能調用函數，不能定義函數。

主函數：

1）、保證該類的獨立運行。

2）、因為它是程序的入口。

3）、因為它在被jvm調用。

函數定義名稱是為什麼呢？

答：1）、為了對該功能進行標示，方便於調用。

2）、為了通過名稱就可以明確函數的功能，為了增加代碼的閱讀性。

重載的定義是：在一個類中，如果出現了兩個或者兩個以上的同名函數，只要它們的參數的個數，或者參數的類型不同，即可稱之為該函數重載了。

如何區分重載：當函數同名時，只看參數列表。和返回值類型沒關係。

7，數 組：用於存儲同一類型數據的一個容器。好處：可以對該容器中的數據進行編號，從0開始。數組用於封裝數據，就是一個具體的實體。

如何在java中表現一個數組呢？兩種表現形式。

1）、元素類型[] 變量名 = new 元素類型[元素的個數]；

2）、元素類型[] 變量名 = {元素1，元素2…}；

元素類型[] 變量名 = new 元素類型[]{元素1，元素2…}；

———————————————————

//二分查找法。必須有前提：數組中的元素要有序。

public static inthalfSeach_2(int[] arr,int key){

int min,max,mid;//定義最小，最大，中間數

min = 0;//最小為0

max =arr.length-1;// 最大為數組的長度-1

mid =(max+min)1; //(max+min)/2;//中間數為最大加最小除以2

while(arr[mid]!=key){//如果數組中間值不等於key

if(keyarr[mid]){//如果key中間值

min = mid+ 1;

}

elseif(key

max = mid- 1;

if(max

return -1;

mid =(max+min)1;

}

return mid;

}

知識拓展：

java內存。

1：寄存器。2：本地方法區。3：方法區。4：棧。5：堆。

棧：存儲的都是局部變量 ( 函數中定義的變量，函數上的參數，語句中的變量 )；

只要數據運算完成所在的區域結束，該數據就會被釋放。

堆：用於存儲數組和對象，也就是實體。啥是實體呢？就是用於封裝多個數據的。

1：每一個實體都有內存首地址值。

2：堆內存中的變量都有默認初始化值。因為數據類型不同，值也不一樣。

3：垃圾回收機制。

java泛型與內部類的三行代碼

改動了一下：

public class out {

public static void main(String[] args) {

out.inString ge1 = new out().new inString();

//以下為測試代碼

ge1.obj = “Hello”;

System.out.println(ge1.obj);

}

class inT {

private T obj;

}

}

定義內部類實例時，用外部類名作限制。

外部類可以訪問內部類的私有成員。

java中什麼叫泛型？

泛型。規定了此集合中元素的類型。例如：\x0d\x0a\x0d\x0aArrayList arr = new ArrayList ();\x0d\x0a\x0d\x0a這樣就創建了一個包含整數的 ArrayList 對象。\x0d\x0a如果要自己定義泛型類，就用如下形式：\x0d\x0a\x0d\x0aclass MyCollection {…}\x0d\x0a\x0d\x0a尖括號中的類型可以有限制，例如你需要讓 MyCollection 中的類型都具有可比性，可以用如下格式：\x0d\x0a\x0d\x0aclass MyCollection {…}\x0d\x0a\x0d\x0a此外，要注意泛型的一些特性：\x0d\x0a\x0d\x0a1. 不能直接創建泛型數組。如 new ArrayList[5] 之類的是錯的。只能用如下方法：new ArrayList[5] 或者 (ArrayList[])new ArrayList[5];\x0d\x0a\x0d\x0a2. 靜態方法中需要小心，因為 E 一般是非靜態類型，如果你這樣寫：\x0d\x0a class MyCollection {\x0d\x0a public static MyCollection abc() {\x0d\x0a ……\x0d\x0a }\x0d\x0a }\x0d\x0a 是錯的。你只能把 去掉。

要學習JAVA，要掌握哪些基礎知識？

java基礎知識如下：

1.繼承、類extends,只能有一個父類，super調用父類，

2.方法重構(名字相同參數不同)，

3.多態(子類的多樣)， final不能繼承-可以被匿名類引用，

上轉型。

4.接口、interface 名，沒有方法體，只能implement實現接口，可以多實現，為實現類提供實現方法的模板規範，可以有成員變量，接口回調。

5.抽象類、abstract 類，含有抽象方法的類，可以含有非抽象方法，只能繼承不能new，和接口的功能類似。

6.泛型類、class 名稱泛型列表（不能是基本類型），聲明泛型 。

7.內部類、在類內部定義的類，只能被這個類使用。

8.匿名類、將一個類的實現作為一個參數。

9.異常類、自定義一個類 MyException繼承Exception類，當執行 StringBuffer類，可以操作字符串的內容（截取，代替，獲取）；StringTokenizer類，可以解析字符串，有兩個構造方法StringTokenizer(字符串，分隔符)，分隔符的任意排列組合，返回結果集，hasMoreTokenizer是否為false來判斷，nextTokens()來獲取下一個對象。

10.正則表達式、字符串對象調用matches(正則表達式)，判斷是否和正則表達式匹配，返回boolean類型；字符串對象調用replaceAll(正則表達式，替換的字符串)產生一個將匹配正則表達式的字串替換後的新的字符串對象；字符串調用split(正則表達式)，返回一個字符串數組，以正則表達式作為分隔符。

11.字符串解析、用Scanner(字符串)類來分隔字符串，Scanner對象調用useDelimiter(正則表達式)來設置分隔符，返回一個結果集，可以精細化的獲取數字型的結果，和非數字型的結果，hasNext()判斷，next/nextInt/nextDouble獲取下一個。

12.模式匹配、建立模式對象Pattern.compile(正則表達式)，建立匹配對象 Pattern對象.matcher(目標字符串)，返回結果集，Matcher對象調用方法find()尋找返回Boolean（類似next()+hasNext()），group()返回匹配的字符串，replaceAll(替換的字符串)返回一個替換了所以匹配的字串的新的字符串,模式可以用|來連接，即正則表達式1|正則表達式2。

java中什麼叫泛型??

有泛型參數，泛型方法，這篇文件寫的很好，你仔細 讀一下，可以多讀幾次，總會有收穫滴

java泛型

java泛型

什麼是泛型？

泛型（Generic type 或者 generics）是對 Java 語言的類型系統的一種擴展，以支持創建可以按類型進行參數化的類。可以把類型參數看作是使用參數化類型時指定的類型的一個佔位符，就像方法的形式參數是運行時傳遞的值的佔位符一樣。

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

因為 Map.get() 被定義為返回 Object，所以一般必須將 Map.get() 的結果強制類型轉換為期望的類型，如下面的代碼所示：

Map m = new HashMap();

m.put(“key”, “blarg”);

String s = (String) m.get(“key”);

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

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

泛型的好處

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

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

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

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

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

該代碼不使用泛型：

List li = new ArrayList();

li.put(new Integer(3));

Integer i = (Integer) li.get(0);

該代碼使用泛型：

ListInteger li = new ArrayListInteger();

li.put(new Integer(3));

Integer i = li.get(0);

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

潛在的性能收益。 泛型為較大的優化帶來可能。在泛型的初始實現中，編譯器將強制類型轉換（沒有泛型的話，程序員會指定這些強制類型轉換）插入生成的字節碼中。但是更多類型信息可用於編譯器這一事實，為未來版本的 JVM 的優化帶來可能。

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

泛型用法的例子

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

Map m = new HashMap();

m.put(“key”, “blarg”);

String s = (String) m.get(“key”);

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

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

public interface MapK, V {

public void put(K key, V value);

public V get(K key);

}

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

類型參數 K 和 V 在類級別的規格說明，表示在聲明一個 Map 類型的變量時指定的類型的佔位符。

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

為了贏得使用泛型的好處，必須在定義或實例化 Map 類型的變量時為 K 和 V 提供具體的值。以一種相對直觀的方式做這件事：

MapString, String m = new HashMapString, String();

m.put(“key”, “blarg”);

String s = m.get(“key”);

當使用 Map 的泛型化版本時，您不再需要將 Map.get() 的結果強制類型轉換為 String，因為編譯器知道 get() 將返回一個 String。

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

向後兼容

在 Java 語言中引入泛型的一個重要目標就是維護向後兼容。儘管 JDK 5.0 的標準類庫中的許多類，比如集合框架，都已經泛型化了，但是使用集合類（比如 HashMap 和 ArrayList）的現有代碼將繼續不加修改地在 JDK 5.0 中工作。當然，沒有利用泛型的現有代碼將不會贏得泛型的類型安全好處。

二 泛型基礎

類型參數

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

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

public interface MapK, V {

public void put(K key, V value);

public V get(K key);

}

Map 接口是由兩個類型參數化的，這兩個類型是鍵類型 K 和值類型 V。（不使用泛型）將會接受或返回 Object 的方法現在在它們的方法簽名中使用 K 或 V，指示附加的類型約束位於 Map 的規格說明之下。

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

MapString, String map = new HashMapString, String();

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

編譯器在遇到一個 MapString, String 類型的變量時，知道 K 和 V 現在被綁定為 String，因此它知道在這樣的變量上調用 Map.get() 將會得到 String 類型。

除了異常類型、枚舉或匿名內部類以外，任何類都可以具有類型參數。

命名類型參數

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

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

V —— 值，比如 List 和 Set 的內容，或者 Map 中的值。

E —— 異常類。

T —— 泛型。

泛型不是協變的

關於泛型的混淆，一個常見的來源就是假設它們像數組一樣是協變的。其實它們不是協變的。ListObject 不是 ListString 的父類型。

如果 A 擴展 B，那麼 A 的數組也是 B 的數組，並且完全可以在需要 B[] 的地方使用 A[]：

Integer[] intArray = new Integer[10];

Number[] numberArray = intArray;

上面的代碼是有效的，因為一個 Integer 是 一個 Number，因而一個 Integer 數組是 一個 Number 數組。但是對於泛型來說則不然。下面的代碼是無效的：

ListInteger intList = new ArrayListInteger();

ListNumber numberList = intList; // invalid

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

ListInteger intList = new ArrayListInteger();

ListNumber numberList = intList; // invalid

numberList.add(new Float(3.1415));

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

類型通配符

假設您具有該方法：

void printList(List l) {

for (Object o : l)

System.out.println(o);

}

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

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

void printList(ListObject l) {

for (Object o : l)

System.out.println(o);

}

它仍然不會通過編譯，因為一個 ListInteger 不是 一個 ListObject（正如前一屏 泛型不是協變的 中所學的）。這才真正煩人 —— 現在您的泛型版本還沒有普通的非泛型版本有用！

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

void printList(List? l) {

for (Object o : l)

System.out.println(o);

}

上面代碼中的問號是一個類型通配符。它讀作“問號”。List? 是任何泛型 List 的父類型，所以您完全可以將 ListObject、ListInteger 或 ListListListFlutzpah 傳遞給 printList()。

類型通配符的作用

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

ListInteger li = new ArrayListInteger();

li.add(new Integer(42));

List? lu = li;

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

為什麼該代碼能工作呢？對於 lu，編譯器一點都不知道 List 的類型參數的值。但是編譯器比較聰明，它可以做一些類型推理。在本例中，它推斷未知的類型參數必須擴展 Object。（這個特定的推理沒有太大的跳躍，但是編譯器可以作出一些非常令人佩服的類型推理，後面就會看到（在 底層細節 一節中）。所以它讓您調用 List.get() 並推斷返回類型為 Object。

另一方面，下面的代碼不能工作：

ListInteger li = new ArrayListInteger();

li.add(new Integer(42));

List? lu = li;

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

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

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

ListInteger li = new ArrayListInteger();

li.add(new Integer(42));

List? lu = li;

lu.clear();

泛型方法

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

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

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

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

return b ? first : second;

}

注意，您可以調用 ifThenElse()，而不用顯式地告訴編譯器，您想要 T 的什麼值。編譯器不必顯式地被告知 T 將具有什麼值；它只知道這些值都必須相同。編譯器允許您調用下面的代碼，因為編譯器可以使用類型推理來推斷出，替代 T 的 String 滿足所有的類型約束：

String s = ifThenElse(b, “a”, “b”);

類似地，您可以調用：

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

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

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

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

當泛型方法是靜態的時，這種情況下不能使用類類型參數。

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

有限制類型

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

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

public class MatrixV extends Number { … }

編譯器允許您創建 MatrixInteger 或 MatrixFloat 類型的變量，但是如果您試圖定義 MatrixString 類型的變量，則會出現錯誤。類型參數 V 被判斷為由 Number 限制 。在沒有類型限制時，假設類型參數由 Object 限制。這就是為什麼前一屏 泛型方法 中的例子，允許 List.get() 在 List? 上調用時返回 Object，即使編譯器不知道類型參數 V 的類型。

三 一個簡單的泛型類

編寫基本的容器類

此時，您可以開始編寫簡單的泛型類了。到目前為止，泛型類最常見的用例是容器類（比如集合框架）或者值持有者類（比如 WeakReference 或 ThreadLocal）。我們來編寫一個類，它類似於 List，充當一個容器。其中，我們使用泛型來表示這樣一個約束，即 Lhist 的所有元素將具有相同類型。為了實現起來簡單，Lhist 使用一個固定大小的數組來保存值，並且不接受 null 值。

Lhist 類將具有一個類型參數 V（該參數是 Lhist 中的值的類型），並將具有以下方法：

public class LhistV {

public Lhist(int capacity) { … }

public int size() { … }

public void add(V value) { … }

public void remove(V value) { … }

public V get(int index) { … }

}

要實例化 Lhist，只要在聲明時指定類型參數和想要的容量：

LhistString stringList = new LhistString(10);

實現構造函數

在實現 Lhist 類時，您將會遇到的第一個攔路石是實現構造函數。您可能會像下面這樣實現它：

public class LhistV {

private V[] array;

public Lhist(int capacity) {

array = new V[capacity]; // illegal

}

}

這似乎是分配後備數組最自然的一種方式，但是不幸的是，您不能這樣做。具體原因很複雜，當學習到 底層細節 一節中的“擦除”主題時，您就會明白。分配後備數組的實現方式很古怪且違反直覺。下面是構造函數的一種可能的實現（該實現使用集合類所採用的方法）：

public class LhistV {

private V[] array;

public Lhist(int capacity) {

array = (V[]) new Object[capacity];

}

}

另外，也可以使用反射來實例化數組。但是這樣做需要給構造函數傳遞一個附加的參數 —— 一個類常量，比如 Foo.class。後面在 ClassT 一節中將討論類常量。

實現方法

實現 Lhist 的方法要容易得多。下面是 Lhist 類的完整實現：

public class LhistV {

private V[] array;

private int size;

public Lhist(int capacity) {

array = (V[]) new Object[capacity];

}

public void add(V value) {

if (size == array.length)

throw new IndexOutOfBoundsException(Integer.toString(size));

else if (value == null)

throw new NullPointerException();

array[size++] = value;

}

public void remove(V value) {

int removalCount = 0;

for (int i=0; isize; i++) {

if (array[i].equals(value))

++removalCount;

else if (removalCount 0) {

array[i-removalCount] = array[i];

array[i] = null;

}

}

size -= removalCount;

}

public int size() { return size; }

public V get(int i) {

if (i = size)

throw new IndexOutOfBoundsException(Integer.toString(i));

return array[i];

}

}

注意，您在將會接受或返回 V 的方法中使用了形式類型參數 V，但是您一點也不知道 V 具有什麼樣的方法或域，因為這些對泛型代碼是不可知的。

使用 Lhist 類

使用 Lhist 類很容易。要定義一個整數 Lhist，只需要在聲明和構造函數中為類型參數提供一個實際值即可：

LhistInteger li = new LhistInteger(30);

編譯器知道，li.get() 返回的任何值都將是 Integer 類型，並且它還強制傳遞給 li.add() 或 li.remove() 的任何東西都是 Integer。除了實現構造函數的方式很古怪之外，您不需要做任何十分特殊的事情以使 Lhist 是一個泛型類。

Java基礎知識總結：什麼時候用泛型類

當類中的操作的引用數據類型不確定的時候，以前用的Object來進行擴展的，現在可以用泛型來表示。這樣可以避免強轉的麻煩，而且將運行問題轉移到的編譯時期。

———————————————————-

泛型在程序定義上的體現：

//泛型類：將泛型定義在類上。

class Tool {

private Q obj;

public void setObject(Q obj) {

this.obj = obj;

}

public Q getObject() {

return obj;

}

}

//當方法操作的引用數據類型不確定的時候，可以將泛型定義在方法上。

publicvoid method(W w) {

System.out.println(“method:”+w);

}

//靜態方法上的泛型：靜態方法無法訪問類上定義的泛型。如果靜態方法操作的引用數據類型不確定的時候，必須要將泛型定義在方法上。

public static void function(Q t) {

System.out.println(“function:”+t);

}

//泛型接口.

interface Inter{

void show(T t);

}

class InterImplimplements Inter{

public void show(R r) {

System.out.println(“show:”+r);

}

}