黑马程序员-----泛型与反射的交叉使用
---------------------- android培训、java培训、期待与您交流！ ----------------------
??ArrayList <Integer> list2 = new ArrayList <Integer>();
??//以下使用反射在使用泛型<Integer>的集合中中加入字符串
??????? list2.getClass().getMethod("add", Object.class).invoke(list2, "abc");
??????? System.out.println(list2.get(0));//在runtime时，不存在泛型实例
??
??//参数化类型与原始类型的兼容性
??????? Vector v1 = new Vector <String>();//原始类型可以引用一个参数化类型的对象
??????? Vector <Object> v2 = v1;//参数化类型可以引用一个原始类型的对象（这里编译器把v1看作是一个原始类型）
??
??//以下内容为类型推断
??????? Integer x = add(3, 4);
??????? Number x1 = add(3.5, 6);//float与int的类型交集为Number
??????? Object x2 = add("a", 665);//String与int的类型交集为Object
??
??private static <T> T add(T x,T y){//用于类型推断的方法
??????? return y;
??}
??
??//运用泛型向任意类型的集合中添加，相应类型的数组内容
??private static <T> void add(Collection <T> dest,T src[]){
??????? for(T s : src){
??????????? dest.add(s);
??????? }
??}
??
??//以下是通过反射获得泛型的的实际参数类型
??????? Method method? = GenericTest.class.getMethod("applyGenericDao", GenericDao.class);
??????? Type[] types = method.getGenericParameterTypes();//Method类提供取得泛型形参类型数组
??????? ParameterizedType pType = (ParameterizedType)types[0];//ParameterizedType是Type的一个子类
??????? System.out.println(pType.getRawType());//运用ParameterizedType的方法返回此类型的类
??????? System.out.println(pType.getActualTypeArguments()[0]);//返回实际类型参数的Type对象
package HEIMA_annotation;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.sql.Date;import java.util.ArrayList;import java.util.Collection;import java.util.HashMap;import java.util.Map;import java.util.Set;import java.util.Vector;import HEIMA_refelct.ReflectPoint;public class GenericTest { public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException { ArrayList list1 = new ArrayList ();//没有使用泛型，编译出现警告 list1.add(1); list1.add("d"); ArrayList<String> list = new ArrayList <String>() ;// list.add(1); list.add("a");// list.add(1L); String i = list.get(0); //new String (new StringBuffer("abc"))反射中使用到泛型 Constructor<String> constructor = String.class.getConstructor(StringBuffer.class); String str = constructor.newInstance(new StringBuffer("abc")); System.out.println(str); ArrayList <Integer> list2 = new ArrayList <Integer>(); //true;字节码相同，说明泛型是提供给编译器使用的，在runtime时没有泛型 System.out.println(list.getClass() == list2.getClass()); //list2.add("abc");编译不通过，因为使用了泛型 //以下使用反射在使用泛型<Integer>中加入字符串 list2.getClass().getMethod("add", Object.class).invoke(list2, "abc"); System.out.println(list2.get(0)); //参数化类型与原始类型的兼容性 Vector v1 = new Vector <String>();//原始类型可以引用一个参数化类型的对象 Vector <Object> v2 = v1;//参数化类型可以引用一个原始类型的对象（这里编译器把v1看作是一个原始类型） HashMap <String, Integer> maps = new HashMap <String, Integer>(); maps.put("zxx", 4); maps.put("lhm", 2); maps.put("zlx", 32); Set <Map.Entry <String, Integer>> entrySet = maps.entrySet();//HashMap无法进行迭代，必须通过entrySet()方法先转化为Set for(Map.Entry <String, Integer> entry : entrySet){ System.out.println(entry.getKey()+":"+entry.getValue()); } //以下内容为类型推断 Integer x = add(3, 4); Number x1 = add(3.5, 6);//float与int的类型交集为Number Object x2 = add("a", 665);//String与int的类型交集为Object swap(new String []{"abc","xyz","jkl"}, 0, 2);// swap(new int[]{1,2,3}, 0, 2);//编译不通过，只有引用类型才能成为泛型的实际参数，int是基本类型 Object obj = "123"; String str1 = autoconvert(obj);//运用泛型转换，但是数据不对会报错 System.out.println(str1); String fillArrayVal = "abc";//运用泛型，在任意类型的数组中，填入相应类型的对象 String [] b = new String[2]; fillArray(b, fillArrayVal); copy1(new Vector <String>(), new String [10]); copy2(new Date[10], new String [10]);//类型推断为Date和String的交集（Object）// copy1(new Vector <Date>(), new String [10]);//编译不通过，前面指—ate，泛型具有传递性，后面也应为Date //以下为自定义泛型类的应用 GenericDao<ReflectPoint> dao = new GenericDao <ReflectPoint>(); dao.add(new ReflectPoint(3,2));//GenericDao类定义了泛型，这里add方法的参数只能是ReflectPoint对象！// String string = dao.findById(1);//编译不通过，定义了泛型，返回类型只能是ReflectPoint类型 //以下是通过反射获得泛型的的实际参数类型 Method method = GenericTest.class.getMethod("applyGenericDao", GenericDao.class); Type[] types = method.getGenericParameterTypes();//Method类提供取得泛型形参类型数组 ParameterizedType pType = (ParameterizedType)types[0];//ParameterizedType是Type的一个子类 System.out.println(pType.getRawType());//运用ParameterizedType的方法返回此类型的类 System.out.println(pType.getActualTypeArguments()[0]);//返回实际类型参数的Type对象 } public static void applyGenericDao(GenericDao<ReflectPoint> dao){ } private static <T> void fillArray(T[] a,T obj){//运用泛型，在任意类型的数组中，填入相应类型的对象 for(T a1 : a){ a1 = obj; System.out.println(a1); } } private static <T> T autoconvert(Object obj){//运用泛型自动将Object对象转换为其他对象(类型错误也会报强制转换错) return (T)obj; } private static <T> void swap(T a[],int i,int j){//转换数组中任意2个元素的位置 T temp = a[i]; a[i] = a[j]; a[j] = temp; } private static <T> T add(T x,T y){//用于类型推断的方法 return y; } private static void printCollection(Collection <?> collection,int i ){//运用通配符，打印任意类型的集合 System.out.println(collection.size()); for(Object arg : collection){ System.out.println(arg); }// collection.add(i);使用通配符后不能使用add方法 } private static <T> void printCollection2(Collection <T> collection,T obj){//运用泛型，打印任意类型的集合(使用通配符更有效) System.out.println(collection.size()); for(Object arg : collection){ System.out.println(arg); } collection.add(obj);//使用泛型后可以使用add方法！ } private static <T> void copy1(Collection <T> dest,T src[]){//运用泛型向任意类型的集合中添加，相应类型的数组内容 for(T s : src){ dest.add(s); } } private static <T> void copy2(T []dest,T src[]){//相同类型的数组传值 } }?
---------------------- android培训、java培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net/heima
?