泛型編程java
㈠ 什麼是泛型
泛型。即通過參數化類型來實現在同一份代碼上操作多種數據兄李類型。泛型是在C#2.0引入的。泛型(Genericity)的字面意思是指具有在多種數據類型上皆可操作旁枯的含意，與模板有些相似。
泛型是程序設計語言的一種特性。允許程序員在強類型程序設計語言中編寫代碼時定義一些可變部分，那些部分在使用前必須作出指明。各種程序設計語言和其編譯器、運行環境對泛型的支持均不一樣。
優點：
泛型方法可以出現在泛型或非泛型類型上。需要注意的是，並不是只要方法屬於泛型類型，或者甚至是方法的形參的類型是封閉類型的泛型參數，就可以說方法是泛型方法。只有當方法具有它自己的類型參數列表運塵洞時，才能稱其為泛型方法。在下面的代碼中，只有方法 G 是泛型方法。
㈡ 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);
該代碼使用泛型：
List<Integer> li = new ArrayList<Integer>();
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 Map<K, V> {
public void put(K key, V value);
public V get(K key);
}
注意該介面的兩個附加物：
類型參數 K 和 V 在類級別的規格說明，表示在聲明一個 Map 類型的變數時指定的類型的佔位符。
在 get()、put() 和其他方法的方法簽名中使用的 K 和 V。
為了贏得使用泛型的好處，必須在定義或實例化 Map 類型的變數時為 K 和 V 提供具體的值。以一種相對直觀的方式做這件事：
Map<String, String> m = new HashMap<String, 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 Map<K, V> {
public void put(K key, V value);
public V get(K key);
}
Map 介面是由兩個類型參數化的，這兩個類型是鍵類型 K 和值類型 V。（不使用泛型）將會接受或返回 Object 的方法現在在它們的方法簽名中使用 K 或 V，指示附加的類型約束位於 Map 的規格說明之下。
當聲明或者實例化一個泛型的對象時，必須指定類型參數的值：
Map<String, String> map = new HashMap<String, String>();
注意，在本例中，必須指定兩次類型參數。一次是在聲明變數 map 的類型時，另一次是在選擇 HashMap 類的參數化以便可以實例化正確類型的一個實例時。
編譯器在遇到一個 Map<String, String> 類型的變數時，知道 K 和 V 現在被綁定為 String，因此它知道在這樣的變數上調用 Map.get() 將會得到 String 類型。
除了異常類型、枚舉或匿名內部類以外，任何類都可以具有類型參數。
命名類型參數
推薦的命名約定是使用大寫的單個字母名稱作為類型參數。這與 C++ 約定有所不同（參閱 附錄 A：與 C++ 模板的比較），並反映了大多數泛型類將具有少量類型參數的假定。對於常見的泛型模式，推薦的名稱是：
K —— 鍵，比如映射的鍵。
V —— 值，比如 List 和 Set 的內容，或者 Map 中的值。
E —— 異常類。
T —— 泛型。
泛型不是協變的
關於泛型的混淆，一個常見的來源就是假設它們像數組一樣是協變的。其實它們不是協變的。List<Object> 不是 List<String> 的父類型。
如果 A 擴展 B，那麼 A 的數組也是 B 的數組，並且完全可以在需要 B[] 的地方使用 A[]：
Integer[] intArray = new Integer[10];
Number[] numberArray = intArray;
上面的代碼是有效的，因為一個 Integer 是 一個 Number，因而一個 Integer 數組是 一個 Number 數組。但是對於泛型來說則不然。下面的代碼是無效的：
List<Integer> intList = new ArrayList<Integer>();
List<Number> numberList = intList; // invalid
最初，大多數 Java 程序員覺得這缺少協變很煩人，或者甚至是「壞的（broken）」，但是之所以這樣有一個很好的原因。如果可以將 List<Integer> 賦給 List<Number>，下面的代碼就會違背泛型應該提供的類型安全：
List<Integer> intList = new ArrayList<Integer>();
List<Number> 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 上編譯通過，但是如果試圖用 List<Integer> 調用它，則會得到警告。出現警告是因為，您將泛型（List<Integer>）傳遞給一個只承諾將它當作 List（所謂的原始類型）的方法，這將破壞使用泛型的類型安全。
如果試圖編寫像下面這樣的方法，那麼將會怎麼樣？
void printList(List<Object> l) {
for (Object o : l)
System.out.println(o);
}
它仍然不會通過編譯，因為一個 List<Integer> 不是 一個 List<Object>（正如前一屏 泛型不是協變的 中所學的）。這才真正煩人 —— 現在您的泛型版本還沒有普通的非泛型版本有用！
解決方案是使用類型通配符：
void printList(List<?> l) {
for (Object o : l)
System.out.println(o);
}
上面代碼中的問號是一個類型通配符。它讀作「問號」。List<?> 是任何泛型 List 的父類型，所以您完全可以將 List<Object>、List<Integer> 或 List<List<List<Flutzpah>>> 傳遞給 printList()。
類型通配符的作用
前一屏 類型通配符 中引入了類型通配符，這讓您可以聲明 List<?> 類型的變數。您可以對這樣的 List 做什麼呢？非常方便，可以從中檢索元素，但是不能添加元素。原因不是編譯器知道哪些方法修改列表哪些方法不修改列表，而是（大多數）變化的方法比不變化的方法需要更多的類型信息。下面的代碼則工作得很好：
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(42));
List<?> lu = li;
System.out.println(lu.get(0));
為什麼該代碼能工作呢？對於 lu，編譯器一點都不知道 List 的類型參數的值。但是編譯器比較聰明，它可以做一些類型推理。在本例中，它推斷未知的類型參數必須擴展 Object。（這個特定的推理沒有太大的跳躍，但是編譯器可以作出一些非常令人佩服的類型推理，後面就會看到（在 底層細節 一節中）。所以它讓您調用 List.get() 並推斷返回類型為 Object。
另一方面，下面的代碼不能工作：
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(42));
List<?> lu = li;
lu.add(new Integer(43)); // error
在本例中，對於 lu，編譯器不能對 List 的類型參數作出足夠嚴密的推理，以確定將 Integer 傳遞給 List.add() 是類型安全的。所以編譯器將不允許您這么做。
以免您仍然認為編譯器知道哪些方法更改列表的內容哪些不更改列表內容，請注意下面的代碼將能工作，因為它不依賴於編譯器必須知道關於 lu 的類型參數的任何信息：
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(42));
List<?> lu = li;
lu.clear();
泛型方法
（在 類型參數 一節中）您已經看到，通過在類的定義中添加一個形式類型參數列表，可以將類泛型化。方法也可以被泛型化，不管它們定義在其中的類是不是泛型化的。
泛型類在多個方法簽名間實施類型約束。在 List<V> 中，類型參數 V 出現在 get()、add()、contains() 等方法的簽名中。當創建一個 Map<K, 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 Matrix<V extends Number> { ... }
編譯器允許您創建 Matrix<Integer> 或 Matrix<Float> 類型的變數，但是如果您試圖定義 Matrix<String> 類型的變數，則會出現錯誤。類型參數 V 被判斷為由 Number 限制 。在沒有類型限制時，假設類型參數由 Object 限制。這就是為什麼前一屏 泛型方法 中的例子，允許 List.get() 在 List<?> 上調用時返回 Object，即使編譯器不知道類型參數 V 的類型。
三 一個簡單的泛型類
編寫基本的容器類
此時，您可以開始編寫簡單的泛型類了。到目前為止，泛型類最常見的用例是容器類（比如集合框架）或者值持有者類（比如 WeakReference 或 ThreadLocal）。我們來編寫一個類，它類似於 List，充當一個容器。其中，我們使用泛型來表示這樣一個約束，即 Lhist 的所有元素將具有相同類型。為了實現起來簡單，Lhist 使用一個固定大小的數組來保存值，並且不接受 null 值。
Lhist 類將具有一個類型參數 V（該參數是 Lhist 中的值的類型），並將具有以下方法：
public class Lhist<V> {
public Lhist(int capacity) { ... }
public int size() { ... }
public void add(V value) { ... }
public void remove(V value) { ... }
public V get(int index) { ... }
}
要實例化 Lhist，只要在聲明時指定類型參數和想要的容量：
Lhist<String> stringList = new Lhist<String>(10);
實現構造函數
在實現 Lhist 類時，您將會遇到的第一個攔路石是實現構造函數。您可能會像下面這樣實現它：
public class Lhist<V> {
private V[] array;
public Lhist(int capacity) {
array = new V[capacity]; // illegal
}
}
這似乎是分配後備數組最自然的一種方式，但是不幸的是，您不能這樣做。具體原因很復雜，當學習到 底層細節 一節中的「擦除」主題時，您就會明白。分配後備數組的實現方式很古怪且違反直覺。下面是構造函數的一種可能的實現（該實現使用集合類所採用的方法）：
public class Lhist<V> {
private V[] array;
public Lhist(int capacity) {
array = (V[]) new Object[capacity];
}
}
另外，也可以使用反射來實例化數組。但是這樣做需要給構造函數傳遞一個附加的參數 —— 一個類常量，比如 Foo.class。後面在 Class<T> 一節中將討論類常量。
實現方法
實現 Lhist 的方法要容易得多。下面是 Lhist 類的完整實現：
public class Lhist<V> {
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; i<size; 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，只需要在聲明和構造函數中為類型參數提供一個實際值即可：
Lhist<Integer> li = new Lhist<Integer>(30);
編譯器知道，li.get() 返回的任何值都將是 Integer 類型，並且它還強制傳遞給 li.add() 或 li.remove() 的任何東西都是 Integer。除了實現構造函數的方式很古怪之外，您不需要做任何十分特殊的事情以使 Lhist 是一個泛型類。
㈢ JAVA 中<t>是什麼意思，
JAVA 中<t>是泛型的意思。
意思是Tree這個類裡面需要用到另外一個類，但是又不能確定要用到的那個類的具體類型，所以暫時用T來代替。
當具體的程序知道要用到的那個類型是什麼的時候就用那個類型來代替T，例如需要實例化一個Tree類，需要用到的那個類是String，那麼就可以這么來實例化Tree<String>()。
(3)泛型編程java擴展閱讀：
定義分類
泛型的定義主要有以下兩種：
1、在程序編碼中一些包含類型參數的類型，也就是說泛型的參數只可以代表類，不能代表個別對象。（這是當今較常見的定義）
2、在程序編碼中一些包含參數的類。其參數可以代表類或對象等等。（人們大多把這稱作模板）不論使用哪個定義，泛型的參數在真正使用泛型時都必須作出指明。
一些強類型編程語言支持泛型，其主要目的是加強類型安全及減少類轉換的次數，但一些支持泛型的編程語言只能達到部分目的。
㈣ 泛型的編程語言
.NET Framework 的泛型
泛型是具有佔位符（類型參數）的類、結構、介面和方法，這些佔位符是類、結構、介面和方法所存儲或使用的一個或多個類型的佔位符。泛型集合類可以將類型參數用作它所存儲的對象的類型的佔位符；類型參數作為其欄位的類型及其方法的參數類型出現。泛型方法可以將其類型參數用作其返回值的類型或者其某個形參的類型。
由於.NET Framework 泛型的類型參數之實際類型在運行時均不會被消除，運行速度會因為類型轉換的次數減少而加快。
另外，使用 GetType 方法可於程序運行時得知泛型及其類型參數的實際類型，更可以運用反射編程。
允許對個別泛型的類型參數進行約束，包括以下幾種形式（假設 C是泛型的類型參數， 是一般類、泛類，或是泛型的類型參數）：T 是一個類。T 是一個值類型。T 具有無參數的公有建構方法。T 實現介面 I 。T 是 C ，或繼承自 C 。
Java 的泛型
Java 泛型的參數只可以代表類，不能代表個別對象。由於 Java 泛型的類型參數之實際類型在編譯時會被消除，所以無法在運行時得知其類型參數的類型。Java 編譯器在編譯泛型時會自動加入類型轉換的編碼，故運行速度不會因為使用泛型而加快。Java 允許對個別泛型的類型參數進行約束，包括以下兩種形式（假設 T 是泛型的類型參數，C 是一般類、泛類，或是泛型的類型參數）：T 實現介面 I 。T 是 C ，或繼承自 C 。一個泛型類不能實現Throwable介面。
C++ 的泛型（模板）
C++ 無法對泛型的類型參數進行約束。在編譯時，每個被使用的封閉泛型類型（即是所有泛型參數的實際類型都已被指明的泛型）都會有獨立的編碼產生，編譯器會在此時確保類型安全性。可是如果泛型要運用其泛型參數的某成員，而該泛型參數又不包含該成員的時候，編譯器所產生的錯誤信息會看似與實際問題無關，增加出錯的難度。
㈤ Java是一種什麼語言
Java是一種計算機編程語言，擁有跨平台、面向對象、泛型編程的特性，廣泛應用於企業級Web應用開發和移動應用開發。
Java編程語言的風格十分接近c++語言。繼承了C++語言面向對象技術的核心，Java舍棄了C++語言中容易引起錯誤的指針，改以引用取代，同時移除原C++與原來運算符重載，也移除多重繼承特性，改用介面取代，增加垃圾回收器功能。在Java SE1.5版本中引入了泛型編程、類型安全的枚舉、不定長參數和自動裝/拆箱特性。太陽微系統對Java語言的解釋是：「Java編程語言是個簡單、面向對象、分布式、解釋性、健壯、安全與系統無關、可移植、高性能、多線程和動態的語言」
Java不同於一般的編譯語言和直譯語言。它首先將源代碼編譯成位元組碼，然後依賴各種不同平台上的虛擬機來解釋執行位元組碼，從而實現了「一次編寫，到處運行」的跨平台特性。在早期JVM中，這在一定程度上降低了Java程序的運行效率。但在J2SE1.4.2發布後，Java的運行速度有了大幅提升。
（1）Java語言的編譯-->解釋-->運行過程
所以說java是一種解釋型的語言。
㈥ JAVA到底是做什麼的
Java是一種廣泛使用的計算機編程語言，擁有跨平台、面向對象、泛型編程的特性，廣泛應用於企業級Web應用開發和移動應用開發。Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。
Java不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。
Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。
(6)泛型編程java擴展閱讀
語言特點：
1、簡單性
Java看起來設計得很像C++，但是為了使語言小和容易熟悉，設計者們把C++語言中許多可用的特徵去掉了，這些特徵是一般程序員很少使用的。
2、分布性
Java設計成支持在網路上應用，它是分布式語言。Java既支持各種層次的網路連接，又以Socket類支持可靠的流（stream）網路連接，所以用戶可以產生分布式的客戶機和伺服器。
3、穩健性
Java原來是用作編寫消費類家用電子產品軟體的語言，所以它是被設計成寫高可靠和穩健軟體的。Java消除了某些編程錯誤，使得用它寫可靠軟體相當容易
4、高性能
Java是一種先編譯後解釋的語言，所以它不如全編譯性語言快。但是有些情況下性能是很要緊的，為了支持這些情況，Java設計者製作了「及時」編譯程序，它能在運行時把Java位元組碼翻譯成特定CPU（中央處理器）的機器代碼，也就是實現全編譯了。