java泛型參數
① 你真的了解java中的泛型E、T、K、V嗎
Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許開發者在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。
但是如果換成其他的字母代替 T ，在可讀性上可能會弱一些。通常情況下，T，E，K，V，？是這樣約定的：？表示不確定的 java 類型。T (type) 表示具體的一個java類型。K V (key value) 分別代表java鍵值中的Key Value。E (element) 代表Element。
② java中什麼叫泛型
泛就是廣泛,泛指,型是數據類型. 在java中為了方便多種數據通用一個結構而引入了這個概念.
比如 class A<E> {}, 那麼E就是一個泛型,它可以替換為任意類型.
class A<E> { E obj; }
在使用時, A<String>相當於定義了class A {String obj;}. A<Integer>相當於定義了class A{Integer obj;}
使用比如A<String> astr = new A<String>(); 那麼astr.obj就是一個String
③ java泛型的參數問題
泛型和多態比較容易混淆, 簡單來說:
泛型就是類型參數化, 好處是編譯器會檢查參數類型.
多態就是多個類由繼承(實現介面)得到的一致外觀, 好處是簡化代碼, 隔絕修改
實際上泛型和多態沒有直接關系, 使用泛型在代碼中就能按照指定類型的外觀操作對象. 比較常用的泛型類型就是List<T>和Map<T, T>, 說個簡單的例子吧:
List<String> list = ....; //具體類型, 就跟多態沒什麼關系了
for (String str : list) {
System.out.println(str.substring(1));
}
List<Animal> list = ...; //地球上但凡講OO的都拿這個說事兒... 成員就是小貓小狗獅子老虎什麼的
for (Animal animal : list) {
animal.say(); //喵, 汪....., 多態
}
④ java中的泛型 求詳細解釋
1、Java泛型
其實Java的泛型就是創建一個用類型作為參數的類。就象我們寫類的方法一樣，方法是這樣的method(String str1,String str2 ),方法中參數str1、str2的值是可變的。而泛型也是一樣的，這樣寫class Java_Generics＜K,V＞，這里邊的K和V就象方法中的參數str1和str2,也是可變。下面看看例子：
//code list 1
import Java.util.Hashtable;
class TestGen0＜K,V＞{
public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0＜String,String＞ t=new TestGen0＜String,String＞();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正確輸出:value
這只是個例子（Java中集合框架都泛型化了，這里費了2遍事.），不過看看是不是創建一個用類型作為參數的類，參數是K，V，傳入的「值」是String類型。這個類他沒有特定的待處理型別，以前我們定義好了一個類，在輸入輸入參數有所固定，是什麼型別的有要求，但是現在編寫程序，完全可以不制定參數的類型，具體用的時候來確定，增加了程序的通用性，像是一個模板。
呵呵，類似C++的模板（類似）。
1.1. 泛型通配符
下面我們先看看這些程序：
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看這個方法有沒有異議，這個方法會通過編譯的，假如你傳入String，就是這樣List＜String＞。
接著我們調用它,問題就出現了，我們將一個List＜String＞當作List傳給了方法，JVM會給我們一個警告，說這個破壞了類型安全，因為從List中返回的都是Object類型的，而讓我們再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List＜String＞ l) {
for (Object o : l)
System.out.println(o);
}
因為這里的List＜String＞不是List＜Object＞的子類,不是String與Object的關系，就是說List＜String＞不隸屬於list＜Object＞,他們不是繼承關系，所以是不行的，這里的extends是表示限制的。
類型通配符是很神奇的，List＜?＞這個你能為他做什麼呢?怎麼都是「？」，它似乎不確定，他總不能返回一個？作為類型的數據吧，是啊他是不會返回一個「？」來問程序員的？JVM會做簡單的思考的，看看代碼吧，更直觀些。
//code list 4
List＜String＞ l1 = new ArrayList＜String＞();
li.add(「String」);
List＜?＞ l2 = l1;
System.out.println(l1.get(0));
這段代碼沒問題的，l1.get(0)將返回一個Object。
1.2. 編寫泛型類要注意：
1) 在定義一個泛型類的時候，在 「＜＞」之間定義形式類型參數，例如：「class TestGen＜K,V＞」，其中「K」 , 「V」不代表值，而是表示類型。
2) 實例化泛型對象的時候，一定要在類名後面指定類型參數的值（類型），一共要有兩次書寫。例如：
TestGen＜String,String＞ t=new TestGen＜String,String＞()；
3) 泛型中＜K extends Object＞,extends並不代表繼承，它是類型範圍限制。
2、泛型與數據類型轉換
2.1. 消除類型轉換
上面的例子大家看到什麼了，數據類型轉換的代碼不見了。在以前我們經常要書寫以下代碼，如：
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
這個我們做了類型轉換，是不是感覺很煩的，並且強制類型轉換會帶來潛在的危險，系統可能會拋一個ClassCastException異常信息。在JDK5.0中我們完全可以這么做，如：
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
這里我們使用泛化版本的HashMap,這樣就不用我們來編寫類型轉換的代碼了，類型轉換的過程交給編譯器來處理，是不是很方便，而且很安全。上面是String映射到String，也可以將Integer映射為String，只要寫成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。
⑤ java中泛型的使用
泛型可以避免強制類型轉換，設定集合對象中存儲的對象類型。
比如List<String> list = new ArrayList<String>();
那在這個list中，只能存儲字元串對象。
⑥ 如何獲取java泛型的參數類型
一般可以使用反射來獲取泛型參數的實際類型，以下是詳細代碼：
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
public class GenericTest {
/*使用反射來獲取泛型信息*/
private Map<String, Integer> score;
public static void main(String[] args) throws SecurityException, NoSuchFieldException {
//Class clazz = GenericTest.class;
Class<GenericTest> clazz = GenericTest.class;
//System.out.println(clazz);
Field f = clazz.getDeclaredField("score");
//直接使用getType只對普通類型有效，無法取到泛型參數
Class<?> a = f.getType();
System.out.println("score的類型是："+a);
//獲得Field實例f的泛型類型
Type gType = f.getGenericType();
//如果gType類型是ParameterizedType的對象
if (gType instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) gType;
//獲取原始類型
Type rType = pType.getRawType();
System.out.println("原始類型是："+rType);
//取得泛型類型參數
Type[] tArgs = pType.getActualTypeArguments();
System.out.println("泛型類型是：");
for (int i = 0; i < tArgs.length; i++) {
System.out.println("第"+i+"個泛型類型是："+tArgs[i]);
}
}else{
System.out.println("獲取泛型類型出錯！");
}
}
}
輸出結果如下：
score的類型是：interface java.util.Map
原始類型是：interface java.util.Map
泛型類型是：
第0個泛型類型是：class java.lang.String
第1個泛型類型是：class java.lang.Integer
⑦ Java 泛型方法的入參參數如：id,如何id限制為String或者Number
首先，你要理解為什麼使用集合框架：如果並不知道程序運行時會需要多少對象，或者需要更復雜方式存儲對象—可以使用java集合框架。
其次，稍微理解一下泛型的機制：將對象的類型作為參數，指定到其它類或者方法上，從而保證類型轉換的安全性和穩定性；本質是參數化類型；創建的集合只能存放<>中寫的類型元素，不能存放別的類型的元素，因此取出元素時也就不需要強轉了；泛型中不能存放基本數據類型等。
通俗的說，就是保證存入集合中的數據的安全性，例如，本來集合中可以存儲各種數據類型的數據有int,string,char等等，只是存進去之後就自動變成Object類型的啦。現在用泛型的話，就是一種約束，即只能存放我們規定的數據類型的元素，如：
ArrayList<String> students = new ArrayList<String>();
現在在集合中只能存放String類型的參數了，此時你要傳入的參數id就只能是String類型的啦。
ArrayList<Student>students = new ArrayList<Student>();
現在在集合中只能存放Studeng類型的參數了，存放其他數據類型時，就會出錯，所以說保證了數據的安全性。
基本就這么多啦，可以多交流，相互幫助，希望可以幫到你呀！！！
⑧ JAVA 回調泛型參數應該怎麼寫
要麼就這樣public
class
Main
{
public
void
test()
public
void
handleCallBack()
{
new
CallBack()
.onFinish(new
Info());
}
public
interface
CallBack
;
public
class
Info
}必須要泛型指定的類型T
在方法內是可見的才能指定吧。。。不過這樣寫和你原本的意圖應當不一樣了。。。因為這樣回調和定義必須寫在一起
否則就不能指定泛型T的類型了。。。
⑨ java泛型的規則限制
1、泛型的類型參數只能是類類型（包括自定義類），不能是簡單類型。
2、同一種泛型可以對應多個版本（因為參數類型是不確定的），不同版本的泛型類實例是不兼容的。
3、泛型的類型參數可以有多個。
4、泛型的參數類型可以使用extends語句，例如<T extends superclass>。習慣上稱為「有界類型」。
5、泛型的參數類型還可以是通配符類型。例如Class<?> classType = Class.forName("java.lang.String");
泛型還有介面、方法等等，內容很多，需要花費一番功夫才能理解掌握並熟練應用。在此給出我曾經了解泛型時候寫出的兩個例子（根據看的印象寫的），實現同樣的功能，一個使用了泛型，一個沒有使用，通過對比，可以很快學會泛型的應用，學會這個基本上學會了泛型70%的內容。
例子一：使用了泛型 classGen<T>{privateTob;//定義泛型成員變數publicGen(Tob){this.ob=ob;}publicTgetOb(){returnob;}publicvoidsetOb(Tob){this.ob=ob;}publicvoidshowType(){System.out.println("T的實際類型是:"+ob.getClass().getName());}}publicclassGenDemo{publicstaticvoidmain(String[]args){//定義泛型類Gen的一個Integer版本Gen<Integer>intOb=newGen<Integer>(88);intOb.showType();inti=intOb.getOb();System.out.println("value="+i);System.out.println("----------------------------------");//定義泛型類Gen的一個String版本Gen<String>strOb=newGen<String>("HelloGen!");strOb.showType();Strings=strOb.getOb();System.out.println("value="+s);}}例子二：沒有使用泛型 classGen2{privateObjectob;//定義一個通用類型成員publicGen2(Objectob){this.ob=ob;}publicObjectgetOb(){returnob;}publicvoidsetOb(Objectob){this.ob=ob;}publicvoidshowTyep(){System.out.println("T的實際類型是:"+ob.getClass().getName());}}publicclassGenDemo2{publicstaticvoidmain(String[]args){//定義類Gen2的一個Integer版本Gen2intOb=newGen2(newInteger(88));intOb.showTyep();inti=(Integer)intOb.getOb();System.out.println("value="+i);System.out.println("---------------------------------");//定義類Gen2的一個String版本Gen2strOb=newGen2("HelloGen!");strOb.showTyep();Strings=(String)strOb.getOb();System.out.println("value="+s);}}運行結果：
兩個例子運行Demo結果是相同的,控制台輸出結果如下：
T的實際類型是:
java.lang.Integer
value= 88
----------------------------------
T的實際類型是: java.lang.String
value= Hello Gen!
Process finished with exit code 0
看明白這個，以後基本的泛型應用和代碼閱讀就不成問題了。