Java学习之反射与泛型

一、泛型和Class类

自java引入了泛型机制，Class类也增加了泛型功能，从而允许使用泛型来限制Class类，例如String.class的类型实际上是Class<String> 。如果Class对应的类型是未知的，则可以使用Class<？>，以通配符的方式来表示，通过反射中使用泛型，可以避免使用反射生成的对象再次需要强制类型转换。

泛型的优点有很多，但最最重要的一点就是可以避免强制类型转换，防止类型转换异常，例子：

public class ObjectFactory {

	public static Object getInstance(String className){
		try {
			Class name = Class.forName(className);
			Object object = name.newInstance();
			return object;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}catch (Exception e) {
			// TODO: handle exception
			return null;
		}
	}
}

上面定義了对象工厂ObjectFactory，可以通过getInstance方法创建一个新对象，调用如下

Date date=(Date) ObjectFactory.getInstance("java.util.Date");

getInstance方法得到的新对象需要进行强制类型转换，才能得到想要的那个对象，如果在类型转换过程中对象转换错误是个什么情况：

Reflection date=(Reflection) ObjectFactory.getInstance("java.util.Date");

上面这段代码在编译时时不会报错的，但在运行时就会抛出ClassCastException异常，因为程序试图把Date对象转换成Reflection对象。

如果泛型进行优化下，就不会出现上面那种的类型转换异常

public class ObjectFactory {


	public static <T>T getInstance(Class<T> clazz){
		
		try {
			return clazz.newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
	}
	
}

在上面的getInstance()方法传入的形参时泛型化的Class实例对象，并通过泛型方法把新对象返回，调用：

Reflection reflection = ObjectFactory.getInstance(Reflection.class);
Date date = ObjectFactory.getInstance(Date.class);

可见，使用反射泛型化，代码安全质量高了一大截，避免了未知类型转换异常错误。

二、使用反射来换取泛型信息

通过指定类对应的 Class 对象，可以获得该类里包含的所有 Field，不管该 Field 是使用 private 修饰，还是使用 public 修饰。获得了 Field 对象后，就可以很容易地获得该 Field 的数据类型，即使用如下代码即可获得指定 Field 的类型。

// 获取 Field 对象 f 的类型
Class<?> a = f.getType();

但这种方式只对普通类型的 Field 有效。如果该 Field 的类型是有泛型限制的类型，如 Map<String, Integer> 类型，则不能准确地得到该 Field 的泛型参数。

为了获得指定 Field 的泛型类型，应先使用如下方法来获取指定 Field 的类型。

// 获得 Field 实例的泛型类型
Type type = f.getGenericType();

然后将 Type 对象强制类型转换为 ParameterizedType 对象，ParameterizedType 代表被参数化的类型，也就是增加了泛型限制的类型。ParameterizedType 类提供了如下两个方法。

getRawType()：返回没有泛型信息的原始类型。

getActualTypeArguments()：返回泛型参数的类型。

下面是一个获取泛型类型的完整程序。

public class GenericTest
{
    private Map<String , Integer> score;
    public static void main(String[] args)
        throws Exception
    {
        Class<GenericTest> clazz = GenericTest.class;
        Field f = clazz.getDeclaredField("score");
        // 直接使用getType()取出Field类型只对普通类型的Field有效
        Class<?> a = f.getType();
        // 下面将看到仅输出java.util.Map
        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

从上面的运行结果可以看出，直接使用 Field 的 getType() 方法只能获取普通类型的 Field 的数据类型：对于增加了泛型参数的类型的 Field，应该使用 getGenericType() 方法来取得其类型。

+

Type 也是 java.lang.reflect 包下的一个接口，该接口代表所有类型的公共高级接口，Class 是 Type 接口的实现类。Type 包括原始类型、参数化类型、数组类型、类型变量和基本类型等。

1.Java学习之泛型

2.Java学习之反射机制