Java 泛型 详解

一、什么是泛型

　　本质而言，泛型指的是参数化的类型。参数化的类型的重要性是：它能让你创建类、接口和方法，由它们操作的数据类型被指定为一个参数。操作参数化类型的类、接口或方法被称为泛型，如泛型类或泛型方法。着重理解的是，通过对Object类型的引用，Java总是可以创建一般化的类、接口和方法，因为Object是所有其他类的超类，一个Object引用可以是任何类型的对象，因此，在泛型出现以前的代码，一般化的类、接口和方法是使用Object引用来操作不同类型的对象（可不可以说是多态？），这样做的问题是不能保证类型安全。泛型添加了它们正缺乏的类型安全，同时还简化了过程，因为不需要显示地在Object和实际操作的数据类型之间进行强制转换。利用泛型，所有的强制转换都是自动和隐含的，因此，泛型扩展了代码复用的能力，而且既安全又方便。

下面是一个简单的泛型例子:

　　

 package com.hujianjie.demo;

 //一个简单的泛型类
 class Gen<T> {
     T ob;

     Gen(T o) {
         this.ob = o;
     }

     T getOb() {
         return ob;
     }

     void showType() {
         System.out.println("Type of T is" + ob.getClass().getName());
     }
 }

 public class GenDemo {
     public static void main(String args[]) {
         // 定义一个Integer类型
         Gen<Integer> iob;
         iob = new Gen<Integer>(88);//此处的<Integer>不能省，因为定义的类型是Integer类型，所以new返回的引用也必须是Integer，否则就会发生编译错误，也即泛型安全
         iob.showType();
         System.out.println("value:" + iob.getOb());
         // 定义一个String 类型
         Gen<String> sob;
         sob = new Gen<String>("Generics Test!");
         sob.showType();
         System.out.println("value:" + sob.getOb());
     }

 }

首先注意，类型Integer被放在Gen后面的一对尖括号内，在本例中，Integer作为类型变元被传递给Gen的类型参数T，这就创建了Gen的一个版本，在该版本中，所有对T的引用都被转换为对Integer的引用，因此，对于这个声明，ob成为Integer类型，且getob（）的返回类型也是Integer类型。String类型也是类似分析。特别主意Java编译器并不创建实际的不同Gen版本或者任何其他的泛型类，尽管将其想象成这样是有帮助理解的，但实际上并不是这样发生的。相反，编译器删除所有的泛型类型信息，并进行必要的强制转换，使代码在行为上就好像创建了Gen的一个特定版本一样，因此，程序中只实际存在一个Gen版本。删除泛型类型信息的过程称为擦拭（erasure)。

二、泛型的特点。

　　1、泛型只使用对象。声明泛型类型的一个实例时，传递给类型参数类型变元必须是类类型，不能使用基本类型，如int或char。

　　2、泛型类型的差异基于类型变元。理解泛型类型的关键在于：对某种特定版本的泛型类型的引用，与对同一种泛型类型的另一种版本的引用是类型不兼容的。例如：上面代码中的 iob=sob 是错误的，虽然iob和sob都属于Gen<T>类型，由于它们的类型参数不同，它们引用的也是不同的类型。这就是泛型添加的类型安全和错误预防的原理所在。

　　3、泛型能在编译时捕捉类型不匹配错误，因此能够创建类型安全的代码。通过泛型，原来的运行时错误现在成了编译错误，这是一个重要的提高。

三、泛型的一般形式

　　声明泛型的语法： class class-name<type-param-list>{ . . . }

　　声明一个泛型引用的语法： class-name<type-arg-list> var-name = new class-name <type-arg-list>(cons-arg-list);

四、泛型的类型

　　1、有界类型。前面简单的例子中，类型参数可以替换为任意的类类型，多数情况下这一点是好的，但是有时候需要对可以传递给类型参数的类型做出限制，于是出现了有界类型。在指定一个类型参数的时候，可以创建一个上界，声明所有的类型变元都必须从超类派生，实现方法是通过在指定类型参数时使用一个extends子句，如下所示：

　　< T extends superclass >

这行代码规定T只能由superclass或它的子类来替换。因此，superclass 提供了一个包括本身在内的上限。

除了用类类型作为有界之外，还可以使用接口类型，实际上，可以将多个接口指定为界，而且，界可以包括一个类类型和多个接口，此时，必须首先指定类类型，当界包含一个接口类型时，只有实现这个接口的类型变元才是合法的，若指定的界包含一个类和一个或者多个接口，则应使用 & 运算符连接它们。例如：

　　class Gen < T extends MyClass & MyInterface > { . . . }

其中， T由称为MyClass 的类和称为MyInterface的接口界定，因此，任何传递给T的类型变元，都必须是MyClass 的一个子类，且实现MyInterface。

　　2、通配符变元。通配符变元用 “？”指定，它代表一个未知类型

 package com.hujianjie.demo;

 /*
  * 定义一个有界泛型类
  */
 class Stats<T extends Number>{
     T[] nums;
     Stats(T [] o){
         nums=o;
     }
     double average(){
         double sum = 0.0;
         for(int i =0;i<nums.length;i++){
             sum+=nums[i].doubleValue();
         }
         return sum/nums.length;
     }
     /*
      * 这里使用通配符变元，如果是Stats<T>,两个比较的对象类型必须一致，否则，
      * 会出现泛型安全错误，所以使用通配符，在不同类型间进行比较
      */
     boolean sameAvg(Stats<?> ob){
         if(this.average()==ob.average())
             return true;
         return false;
     }
 }

 public class WildCardDemo {

     /**
      * @param args
      */
     public static void main(String[] args) {

         Integer inums[]={1,2,3,4,5};
         Stats<Integer> iob = new Stats<Integer>(inums);
         System.out.println("iob average is :"+iob.average());
         Double dnums[]={1.1,2.2,3.3,4.4,5.5};
         Stats<Double> dob = new Stats<Double>(dnums);
         System.out.println("dob average is :"+dob.average());
         Float fnums[]={1.0f,2.0f,3.0f,4.0f,5.0f};
         Stats<Float> fob = new Stats<Float>(fnums);
         System.out.println("dob average is :"+fob.average());
         if(iob.sameAvg(dob))
             System.out.println("iob and dob are the same!");
         else
             System.out.println("iob and dob are not the same!");
         if(fob.sameAvg(iob))
             System.out.println("iob and fob are the same!");
         else
             System.out.println("iob and fob are not the same!");
     }

 }

　　3、有界通配符。通配符变元的界定方式与类型参数大体相同，当创建一个操作与类层次的泛型时，有界通配符尤其重要。一个有界通配符可以为类型变元指定一个上界或一个下界。如：在坐标系里，二维、三维、四维坐标，如果要限定在一个三维坐标中，则可以使用如下方式：showXYZ(Coords< ? extends ThreeD> ob).

　　4、泛型构造函数。构造函数也可以是泛型，即使它们的类也不是泛型。

　　5、泛型接口。泛型接口的指定方法与泛型类相似。

 package com.hujianjie.demo;
 /*
  * 定义一个泛型上界接口，所传对象必须实现Comparable接口，可以比较大小
  */
 interface MinMax<T extends Comparable<T> >{
     T min();
     T max();
 }
 /*
  * 定义实现接口类时注意：MyClass声明参数类型 T 后要将它传递给MinMax，因为MinMax
  * 需要一个实现Comparable的类型，实现类必须指定同样的界
  * 此界一旦建立，就无需在implements字句中再次指定。
  * class MyClass <T extends Comparable<T> > implements MinMax< T extends Comparable<T> >
  * 这样指定是错误的
  */
 class MyClass <T extends Comparable<T> > implements MinMax<T>{
     T [] array;
     MyClass (T []o){
         array=o;
     }
     public T min(){
         T minValue =array[0];
         for(int i=0;i<array.length;i++){
             if(minValue.compareTo(array[i])>0)
                 minValue=array[i];
         }
         return minValue;
     }
     public T max(){
         T maxValue = array[0];
         for(int i=0;i<array.length;i++){
             if(maxValue.compareTo(array[i])<0){
                 maxValue=array[i];
             }
         }

         return maxValue;

     }
 }

 public class GenIFDemo {

     /**
      * @param args
      */
     public static void main(String[] args) {
         Integer inums[]={3,6,2,8,7};
         Character chs[]={'b','r','c','d'};
         MyClass<Integer> iob = new MyClass<Integer>(inums);
         MyClass<Character> cob = new MyClass<Character>(chs);
         System.out.println("Max values in inums is "+iob.max());
         System.out.println("Min values in inums is "+iob.min());
         System.out.println("Max values in chs is "+cob.max());
         System.out.println("Min values in chs is "+cob.min());
     }

 }

注意：如果一个类实现了一个泛型接口，则此类必须也是泛型，或者至少它接受传递给接口的类型参数。如果MyClass是一个没有引用泛型的类，只是实现了泛型接口如下声明，编译器会报错。

 class MyClass implements MinMax< T >{ . . . }

另外，如果上面的情况稍作改变就不同，如果类实现一个泛型接口的特定类型，则此实现类不需要是泛型的

 class MyClass implements MinMax< Integer>{ . . . }

　　6、泛型类层次。和非泛型类一样，泛型类也可以是类层次中的一部分，因此，泛型类可以作为超类或子类。泛型类层次与非泛型类层次的关键区别在于：泛型类层次中，全部子类必须将泛型超类需要的类型变元沿层次向上传递。这与构造函数变元必须沿层次向上传递的方式类似。

 package com.hujianjie.demo;
 class Gen <T>{
     T ob;
     Gen (T o){
         ob =o;
     }
     T getOb(){
         return ob;
     }
 }
 class Gen2<T> extends Gen<T>{
     Gen2(T o){
         super(o);
     }
 }

 public class HierDemo {

     /**
      * @param args
      */
     public static void main(String[] args) {
         Gen<Integer> iob = new Gen<Integer>(88);
         Gen2<Integer> iob2 = new Gen2<Integer>(99);
         Gen2<String> str2 = new Gen2<String>("Generics Test");
         if(iob instanceof Gen<?>)
             System.out.println("iob is instance of Gen");
         //iob 向下转型，将不是Gen2对象的类型
         if(iob instanceof Gen2<?>)
             System.out.println("iob is instance of Gen2");
         if(iob2 instanceof Gen<?>)
             System.out.println("iob2 is instance of Gen");
         if(iob2 instanceof Gen2<?>)
             System.out.println("iob2 is instance of Gen2");
         if(str2 instanceof Gen<?>)
             System.out.println("str2 is instance of Gen");
         if(str2 instanceof Gen2<?>)
             System.out.println("str2 is instance of Gen2");
         /*
          * 以下这些行不能被编译的原因是：它们试图比较iob2与Gen2的一个特定
          * 类型，本例中是Gen2<Integer>.记住，在运行时无法得到泛型类型信息，因此
          * 对instanceof来说，无法判断iob2是否为Gen2<Integer>的一个实例
          */
     //    if(iob2 instanceof Gen2<Integer>)
     //        System.out.println("str2 is instance of Gen2");

     }

 }

结果：

 iob is instance of Gen
 iob2 is instance of Gen
 iob2 is instance of Gen2
 str2 is instance of Gen
 str2 is instance of Gen2

五、泛型擦拭

　　大体而言，擦拭的工作方式是这样的：当编译Java代码时，全部泛型类型信息被移去（擦拭）。这意味着使用它们的界定类型来替换类型参数，如果没有显式地指定界，则界定类型是Object，然后运用适当得强制转换（由类型变元决定），以维持与类型变元指定的类型的兼容。编译器也会强制这种类型兼容。对泛型来说，这种方法意味着在运行时不存在类型参数，它们仅是一种源代码机制。在编译时所有的类型参数都被擦拭掉了，在运行时，只有原始类型实际存在。