java 泛型获取class java 获取泛型的类型

一般使用反射来获取泛型类型信息
如下代码：

package myGenetic;

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("获取泛型类型出错！");
		}
	}
}

输出结果如下：

[b]score的类型是：interface java.util.Map

原始类型是：interface java.util.Map

泛型类型是：

第0个泛型类型是：class java.lang.String

第1个泛型类型是：class java.lang.Integer[/b]

还有一个较好的例子，多用于实现BaseDAO，代码如下：

package myGenetic;

import java.lang.reflect.ParameterizedType;

class SubClass extends SuperClass<Person> {  

    public SubClass() {  
        super();  
    }  

}  

class Person {  
    public Person() {  
        super();  
    }  

    public void function() {  
        System.out.println("function in Person.class...");  
    }  
}  


public abstract class SuperClass<T> {
	 private Class<T> clazz;

	 @SuppressWarnings("unchecked")  
	    public SuperClass() {  
	        clazz = (Class<T>) ((ParameterizedType) super.getClass()  
	                .getGenericSuperclass()).getActualTypeArguments()[0];
	    }  

	    public Class<T> getClazz() {  
	        return clazz;  
	    }  

	    public void setClazz(Class<T> clazz) {  
	        this.clazz = clazz;  
	    }

	    /** 
	     * 普通的非泛型类Class 
	     * 泛型化的类Class<T> 
	     * JDK中，普通的Class.newInstance()方法的定义返回Object，要将该返回类型强制转换为另一种类型; 
	     * 但是使用泛型的Class<T>，Class.newInstance()方法具有一个特定的返回类型; 
	     * @param args 
	     */  
	    public static void main(String[] args) {  
	        SuperClass<Person> subClass = new SubClass();  
	        //1.得到泛型类T实际的完整类名  
	        System.out.println(subClass.getClazz());  
	        //2.得到泛型类T的对象  
	        try {  
	            System.out.println(subClass.getClazz().newInstance());  
	        } catch (InstantiationException e) {  
	            e.printStackTrace();  
	        } catch (IllegalAccessException e) {  
	            e.printStackTrace();  
	        }  
	        //3.调用泛型类T的方法  
	        try {  
	        	subClass.getClazz().newInstance().function();  
	        } catch (InstantiationException e) {  
	            e.printStackTrace();  
	        } catch (IllegalAccessException e) {  
	            e.printStackTrace();  
	        }  
	    }  
}

输出结果如下：

[b]class myGenetic.Person 

myGenetic.Person@10d448 

function in Person.class...[/b]