Java-泛型(Generic)深入使用(与反射结合使用)

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

总结:泛型只在编译器时期有效，在运行时期无效，在运行时期，它指明的“类型”信息会去掉如：

1.泛型(只针对引用类型)使用规则

   ArrayList类定义和ArrayList类引用中涉及如下术语：整个称为ArrayList泛型类型

   ArrayList中的E称为类型变量或类型参数整个ArrayList称为参数化的类型

   ArrayList中的Integer称为类型参数的实例或实际类型参数

   ArrayList中的<>念着typeof

   ArrayList称为原始类型

   参数化类型与原始类型的兼容性：

   参数化类型可以引用一个原始类型的对象，编译报告警告，

     例如， Collection<String> c = new Vector();//可以

   原始类型可以引用一个参数化类型的对象，编译报告警告，例如，

      Collection c = new Vecto<String>r();//可以。

   第三种情况：

      Vector v1=new Vector<String> ();//符合最上面的情况

      Vector<Object> v=v1; //也可以，符合上面第二种情况

   参数化类型不考虑类型参数的继承关系：

      Vector<String> v = new Vector<Object>();//错误

      Vector<Object> v=new Vector<String>();//错误

2.泛型中的？通配符

   问题：定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？

   错误方式：

      public static void printCollection(Collectioncols) { 

             for(Object obj:cols) { System.out.println(obj); } 

             /* cols.add("string");//没错 cols = new HashSet();//会报告错误！*/ } 

   正确方式：

public static void printCollection(Collection<?> cols) {     

                for(Object obj:cols) { System.out.println(obj); }  

               //cols.add("string");//错误，因为它不知自己未来匹配就一定是String    

               cols.size();//没错，此方法与类型参数没有关系      

               cols = new HashSet<Date>();     }

   总结： 使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，

            不能调用与参数化类型有关的方法。

3.泛型中的？通配符的扩展

    限定通配符的上边界：

      正确：Vector x = new Vector();

      错误：Vector x = new Vector();

    限定通配符的下边界：

        正确：Vector x = new Vector();

        错误：Vector x = new Vector();

     <?>与<E>

          class<?> c=new class<E> ();//正确

          class<E> c=new class<?>();//错误，即？可以“=”任意参数，但是特定参数化类型“=”？错误。

    总结：限定通配符总是包括自己。 ?只能用作引用，不能用它去给其他变量赋值

         Vector y = new Vector(); Vector x = y;

        上面的代码错误，原理与Vectorx11 = new Vector();相似，

        只能通过强制类型转换方式来赋值。

4.定义泛型的方法

•  Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，
•  用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）
•  Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译： <T> T add(T x,T y) {   return (T) (x+y);      
•    //return null;     } 用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是
•   紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。
•  除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。
•  并且可以用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}

1. 只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3,5);语句会报告编译错误。
2. 普通方法、构造方法和静态方法中都可以使用泛型。
3. 也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

     在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，

     例如： public static <K,V> V getValue(K key) { return map.get(key);}

//<T>必须声明，这是对你使用“T”的解析，<T extends U&V>也可以,<T super U>不可以   

      public   <T> T method1(T x,T y) {  

         return y;  

      }    

     public  <T extends Number> void method2(T x)     {       

       }    

//多个参数的T    

   public static <K,V> V getValue(K key)     {  

        V map = null;        

        return  (V) ((ArrayList<Integer>) map).get((int) key);         

       }     

  //异常如何采用泛型   

     private static <T extends Exception> void sayHello() throws T     {  

            try{    

                    }catch(Exception e)

                       {      

                           throw (T)e;     

                        }     

      }

5.定义泛型的类

public class GenericDao<E> {   

      //多个方法使用的E类，放在该类上面声明<E>    

        public void add(E e)     {         
          }   

     //静态方法使用的E，必须用自己方法上声明的<E>,不能使用类上面声明的<E>    

         public static<E> void method(E e)     {     

          }   

         public void update (E e)     {        

        } }

注意： 在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。 当一个变量被声明为泛型时，

          只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类

          所共享的，所以静态成员不应该有类级别的类型参数

6.Type(接口)

Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

    java.lang.reflect 接口 Type

      所有已知子接口：

GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType

     所有已知实现类：

 Class

7.反射，泛型的高级应用

public class GenericTest {

    public static void main(String[] args) throws Exception {     

   //如何获取某个方法上声明的特定泛型类型         

   //如：public void applyVector(Vector<Date> v);如何得知该Vector是Date,即如何获取<T>里的泛型类型       

   //解决：使用反射的Method类里的getGenericParameterTypes()获取该方法上的泛型类型   

      Method  applyMethod=GenericTest.class.getMethod("applyVector", Vector.class,Set.class);     

      Type [] tp= applyMethod.getGenericParameterTypes();         

      System.out.println(tp[0]);            

      ParameterizedType p=(ParameterizedType) tp[1];        

      System.out.println(p.getActualTypeArguments()[0]);   

     }   

    public void applyVector (Vector<Date> v,Set<HashSet> s)       {           
      }

}

Java-泛型(Generic)深入使用(与反射结合使用)

原文：http://www.cnblogs.com/beyondbycyx/p/4312213.html