1. package cn.itcast.day2;
   
2. 
   
3. import java.lang.reflect.ParameterizedType;
   
4. import java.lang.reflect.Type;
   
5. import java.lang.reflect.TypeVariable;
   
6. import java.util.ArrayList;
   
7. import java.util.Collection;
   
8. 
   
9. public class GenericQuestion {
   
10. 
    
11.         /**
    
12.          * @param args
    
13.          * @throws Exception
    
14.          */
    
15.         public static void main(String[] args) throws Exception {
    
16.                
    
17.                 ArrayList<String> collection1 = new ArrayList<String>();
    
18.                 Collection<? extends Number> collection2 = new ArrayList<Byte>();
    
19.                
    
20.                 getCollectionTypeOfParameter(collection1);
    
21.                 getCollectionTypeOfParameter(collection2);        
    
22.         }
    
23. 
    
24.         
    
25. /*        用反射方式获取参数列表中类型变量*/
    
26.         public static void getCollectionTypeOfParameter(Collection<?> src)
    
27.                         throws Exception{
    
28. 
    
29.                 TypeVariable<?>[] typeVariable = src.getClass().getTypeParameters();
    
30. //                获取引用的通用声明(GetGenericDeclaration)的类型变量(API中对其声明的类型变量)
    
31.                 System.out.println(typeVariable[0].getGenericDeclaration());
    
32. //                获取引用的类型               
    
33.                 System.out.println(typeVariable[0].getName());
    
34. //                获取类型变量的上边界，上边界一般为Object(除非<? extends Number>，则为Number)
    
35.                 Type[] type = typeVariable[0].getBounds();
    
36.                 System.out.println(type[0]);
    
37. 
    
38.                
    
39. //                获取方法的原始参数类及其类型变量
    
40.                 Type[] types = GenericQuestion.class.getMethod
    
41.                                 ("getCollectionTypeOfParameter", Collection.class).getGenericParameterTypes();
    
42.                 ParameterizedType typeOfParameter = (ParameterizedType)types[0];
    
43.                 System.out.println(typeOfParameter.getRawType());                                //原始参数类型
    
44.                 System.out.println(typeOfParameter.getActualTypeArguments()[0]);//类型参数
    
45.         }
    
46. }

复制代码

/*        
        由于java中泛型是用于编译器行类型检查和类型推断的，在正式运行生成原始类的字节码时会用擦除技术抹去，
        所以貌似不可能实现获取引用的实例化类型参数。不过还是要问哈童鞋们，这种方式能实现么？即上述方法中
        如果传入的引用类型是ArrayList<String>，能否就得到原始类 ArrayList和类型变量String呢？  
*/

1. package com.test;
   
2. 
   
3. import java.lang.reflect.Method;
   
4. import java.lang.reflect.ParameterizedType;
   
5. import java.lang.reflect.Type;
   
6. import java.util.ArrayList;
   
7. 
   
8. public class Test1 {
   
9.         //声明一个传入ArrayList<String>类型参数的方法，不需要方法体
   
10.         public static void noUse(ArrayList<String> alist){}
    
11.        
    
12.        
    
13.         public static void main(String[] args) throws Exception{
    
14.                 //通过反射得到刚刚声明的方法
    
15.                 Method method = Test1.class.getMethod("noUse",ArrayList.class);
    
16.                 //得到这个方法的参数列表
    
17.                 Type[] types = method.getGenericParameterTypes();
    
18.                 //如果第一个参数是参数化类型，下面就好办了
    
19.                 if(types[0] instanceof ParameterizedType){
    
20.                         ParameterizedType pType = (ParameterizedType)types[0];
    
21.                         Type[] temp = pType.getActualTypeArguments();
    
22.                         System.out.println(temp[0]);//输出：class java.lang.String
    
23.                 }
    
24.                
    
25.         }
    
26. }

复制代码

刚刚翻了半天资料，终于找到了一种解决方案。
看看对你有没有用。

  na shi 必须能的  多看一些张孝祥老师的视频把

王洪宇 发表于 2013-4-14 10:26
刚刚翻了半天资料，终于找到了一种解决方案。
看看对你有没有用。

虽然不是我想要的，但是还是谢谢。