如何知道一個java對象的泛型類型

① 如何獲取 java 的泛型中的對象類型

/**
*獲取field的類型，如果是復合對象，獲取的是泛型的類型
*
*@paramfield
*@return
*/
(Fieldfield){
ClassfieldClazz=field.getType();

if(fieldClazz.isAssignableFrom(List.class)){
Typefc=field.getGenericType();//關鍵的地方，如果是List類型，得到其Generic的類型

if(fcinstanceofParameterizedType)//如果是泛型參數的類型
{
ParameterizedTypept=(ParameterizedType)fc;

fieldClazz=(Class)pt.getActualTypeArguments()[0];//得到泛型里的class類型對象。
}
}

returnfieldClazz;
}

正好這幾天剛寫了相關代碼，供參考

② java中如何知道一個Class的泛型Class

String s = "";
s.getClass().getSuperclass();
如租察果返回值為null 說明已經是最高睜派級別的了悉型賀，一般object的superclass才為null

③ 如何獲取 java 的泛型中的對象類型

獲取java泛型中的對象類型，可以參考如下代碼：

/**
*通過反射取到List<T>中T的類型
*@paramclazz
*@paramfield
*拿祥@return
*/
publicstaticClass<?extendsObject>getGenericType(Class<?extendsObject>clazz,Fieldfield){
MethodgetMethod=肢伏getGetMethodByField(clazz,field);
ParameterizedTypept=(ParameterizedType)getMethod.getGenericReturnType();

Class<?extendsObject>type歷敏攜=(Class<?>)pt.getActualTypeArguments()[0];
//System.out.println(type.getSimpleName());
//System.out.println(type.getPackage());
returntype;
}

④ 如何獲取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怎麼獲取一個泛型方法的真實泛型類型

用gentyref這個工具應該能解決你的問題。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import com.googlecode.gentyref.GenericTypeReflector;

public class ClassWithGenericMethod {

public <T> void chill(List<T> aListWithTypeT) {
System.out.println(GenericTypeReflector.getTypeParameter(aListWithTypeT.getClass(), Collection.class.getTypeParameters()[0]));
}

public void chillWildcard(List<?> aListWithTypeWildcard) {
System.out.println(GenericTypeReflector.getTypeParameter(aListWithTypeWildcard.getClass(), Collection.class.getTypeParameters()[0]));
}

public <T> T chillReturn(Class<T> c) {
T ret = null;
try {
ret = c.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
System.out.println(ret.getClass());
return ret;
}

public static void main(String... args) {
ClassWithGenericMethod cwfm = new ClassWithGenericMethod();
cwfm.chill(new ArrayList<String>(){});
cwfm.chillWildcard(new ArrayList<Integer>(){});
cwfm.chillReturn(ClassWithGenericMethod.class);
}

}

⑥ 請問Java怎麼取得一個對象的泛型類型

//泛型並沒有想像中那那麼強力……
//換句話說就是裡面什麼都能放
//判斷這個列表是什麼類型的並沒有意義

import java.util.ArrayList;
import java.util.List;

public class Main{

public static void printType(Object object){
if(object instanceof List){
List list=(List)object;//什麼都能放
list.add(new Main());

if(!list.isEmpty()){
for(Object o:list)
System.out.println(o.getClass().getSimpleName());

//System.out.println("object是List<String>類型螞御高旁");
}else{
System.out.println("object是List，但是不是悶念岩List<String>類型");
}
}else{
System.out.println("object不是List類型");
}
}

public static void main(String[] args){

List<String> list=new ArrayList<String>();
list.add("haha");
list.add("what?");
printType(list);
}
}

⑦ java怎麼得到泛型的類型

泛型，就是廣泛的類型。剛開始要用到哪個都不會知道。只有去實例化對象的時候才能確定。泛型的參數只能是對象類型。
你這個程序，T entity-entity就是是一個泛型的引用,你可以在構造方法中為其具體賦值.
例如:
private T entity;
public HibernateDao(T entity)
{this.entity=entity;}
HibernateDao<Strng> h=new HibernateDao<String>("哈哈");

這時,泛型就代表棗早一個String對象.值是哈哈.

在沒有泛型之前,這種坦核形式一般都是先定義一個通凳信雀用的Object obj.然後在構造方法中為其賦值.

⑧ Java中定義泛型<T>時，怎麼獲得泛型的類型

T.getClass()或者T.class都是非法的，因為T是泛型變數。
由於一個類的類型是什麼是在編譯期處理的，故不能在運行時直接在Base里得到T的實際類型。
有一種變通的實現方式：
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Generic extends Base<String> {
public static void main(String[] args) {
Generic c = new Generic();
System.out.println(c.array);
}

Object array ;
public Generic() {
array = Array.newInstance(getGenericType(0), 100);
}
}

class Base<T> {
public Class getGenericType(int index) {
Type genType = getClass().getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
throw new RuntimeException("Index outof bounds");
}
if (!(params[index] instanceof Class)) {
return Object.class;
}
return (Class) params[index];
}
}
其中Base<T>是泛型類，在父類中聲明getGenericType，子類繼承具體的Base<String>，那麼在子類中就可以通過getGenericType(0)獲取到String的class.