JAVA基础知识之JVM-——反射和泛型

泛型和Class类

在反射中使用泛型Class<T>可以避免强制类型转换，下面是一个简单例子，如果不使用泛型的话，需要显示转换，

package aop;

import java.util.Date;

import javax.swing.JFrame;

public class ObjectFactory {
    public static Object getInstance(String clsName) {
        try {
            Class cls = Class.forName(clsName);
            return cls.newInstance();        
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    public static void main(String[] args) {
        Date d = (Date)ObjectFactory.getInstance("java.util.Date");
        JFrame f = (JFrame)ObjectFactory.getInstance("java.util.Date");
    }
}

上面的例子第19行和20行都需要将Class的newInstance返回的Object结果强制转换成目标类型，这不仅麻烦，更重要的是有些情况下无法发现错误，

例如第20行，强制转换可以通过编译的，但是运行期间可能会报错，原因是强制将Date类型转换成JFrame类型，类型不匹配，下面是执行结果，

1 Exception in thread "main" java.lang.ClassCastException: java.util.Date incompatible with javax.swing.JFrame
2     at aop.ObjectFactory.main(ObjectFactory.java:20)

下面用泛型来实现getInstance，  即  public static <T> T getInstance(Class<T> cls)

package aop;

import java.util.Date;

import javax.swing.JFrame;

public class ObjectFactory2 {
    public static <T> T getInstance(Class<T> cls) {
        try {
            return cls.newInstance();        
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    public static void main(String[] args) {
        Date d = ObjectFactory2.getInstance(Date.class);
        JFrame f = ObjectFactory2.getInstance(JFrame.class);
    }
}

上面的第19行如果类型不符，例如写成了JFrame f = ObjectFactory2.getInstance(Date.class); ， 则无法通过编译，

必须要修改成匹配的类型才能通过编译， 很好地编码了隐形错误。

泛型和数组

泛型中的数组虽然也使用了泛型编程，但却没有实现泛型功能， 泛型数组的newInstance方法签名是这样的，

public static Object newInstance(Class<?> componentType, int... dimensions)

虽然上面的定义也使用了泛型，但是却没有真正实现泛型，所以这个方法返回的对象arr依然是个Object类型，要当成数组使用的话还是需要强制转换成数组类型。

如果将上面的方法签名改成这样，

public static <T> T[] newInstance(Class<T> componentType, int length)

这样返回的arr就是个数组类型了，无需强制转换就可以当作数组用。

下面是一个将反射(reflect)中的Array的newInstance包装成泛型之后再使用的例子，

package aop;

import java.lang.reflect.Array;

public class MyArray {
    public static <T> T[] newInstance(Class<T> componentType, int length) {
        return (T[])Array.newInstance(componentType, length);
    }
    
    public static void main(String[] args) {
        //使用MyArry的newInstance创建数组
        String[] arr = MyArray.newInstance(String.class, 10);
        //使用MyArray的newInstance创建二维数组
        int[][] intArr = MyArray.newInstance(int[].class, 5);
        arr[5] = "天王盖地虎";
        intArr[1] = new int[]{23,12};
        System.out.println(arr[5]);
        System.out.println(intArr[1][1]);
    }
}

输出结果， 可以看到上面已经刻在无需强制转换成数组的情况下，直接将arr和intArr作为数组来使用了，

天王盖地虎
12

 使用反射来获取泛型信息

通过反射可以获取指定类的成员变量， 方法是 Field f = clazz.getDeclaredField("成员变量名称");

之后，可以用f对象获取它的类型，对于普通类型的成员变量，可以用Class<?> a = f.getType(); 方式获取

但是对于泛型的成员变量，例如 Map<String, Integer> score; getType()只能获取原始类型，这里是Map

如果要获取泛型类型（即尖括号里面的参数类型),

1. 首先需要获取成员变量的泛型类型， 通过Type gType = f.getGenericType();
2. 然后将泛型对象gType强制转换成参数化类型ParameterizedType的对象pType；  （ParameterizedType包含两个方法，getRawType(), 返回原始类型，和上面的getType一样。getActualTypeArguments(), 返回泛型参数的类型，也就是Map<String, Integer> 括号里的类型）
3. 使用getActualTypeArguments()返回泛型信息

下面来演示一下使用反射来获取泛型信息，

package aop;


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 Exception {
        Class<GenericTest> clazz = GenericTest.class;
        Field f = clazz.getDeclaredField("score");
        //getType只能取出普通类型,因此下面的a只能得到java.util.Map类型
        Class<?> a = f.getType();
        System.out.println("score的类型是： " + a);
        //获取泛型类型
        Type gType = f.getGenericType();
        // 如果gType类型是ParameterizedType对象
        if (gType instanceof ParameterizedType) {
            //泛型对象强制转换成参数化类型对象
            ParameterizedType pType = (ParameterizedType)gType;
            //获取原始类型，即java.util.Map
            Type rType = pType.getRawType();     
            System.out.println("原始类型： "+rType);
            //获取泛型括号里面参数的类型
            System.out.println("泛型参数类型：");
            Type[] tArgs = pType.getActualTypeArguments();
            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