java獲取泛型類型

❶ java反射：怎麼取出類的泛型類

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;
}

❷ 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.

❸ 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

❹ java怎麼獲取帶泛型的介面中的泛型類

反射可以實現.
//獲得泛型集合
Type[] actualTypeArguments = class文件.getActualTypeArguments();
//實體類型
Class<T> domainClass = (Class<T>) actualTypeArguments[0];

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

不知道我對你的題目的理解對不對：有個方法返回一個 泛型 ，你想去這個 泛型 的類型是不是？

packagetest;

importjava.util.ArrayList;
importjava.util.List;

publicclassTest01{

	publicstaticvoidmain(String[]args){
		List<String>strings=newArrayList<String>();
		strings.add("123");//模擬返回一個泛型
		
		System.out.println(strings.getClass());//第一次取類型
		System.out.println(strings.get(0).getClass());//假如通過第一步知道是ArrayList類型，則再取類型
	}
}

輸出結果：

class java.util.ArrayList

class java.lang.String

這里只舉例講一下方法，不知道是不是你想要的，

❽ 如何獲取 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;
}

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