漫谈Java的泛型机制

泛型是Java 1.5引入的新特性。泛型的本质是参数化类型，这种参数类型可以用在类、变量、接口和方法的创建中，分别称为泛型类、泛型变量、泛型接口、泛型方法。将集合声明参数化以及使用JDK提供的泛型和泛型方法是相对简单的，而编写自己的泛型类型会比较困难，但是还是值得思考与学习如何去编写。

1、泛型的优势

提高代码的安全性和表述性
在没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。一个错误的示范如下：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add("String");
        int isInt = (int) list.get(1); //ClassCastException
    }

本例中对于强制类型转换错误的情况，编译器在编译时并不提示错误，在运行的时候才出现ClassCastException异常，这样便存在着安全隐患。（Effective Java第23条：请不要在新代码中使用原生态类型）
提高代码的重用率
利用泛型类可以选择具体的类型对类进行复用相对比较容易理解，具体的说明如下：

public class Box<T> {
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

这样我们的Box类便可以得到复用，我们可以将T替换成任何我们想要的类型：

Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
Box<String> stringBox = new Box<String>();

2、泛型的使用

泛型类
泛型类中使用通配泛型T相比较用Object类型强制转换的优势已经介绍过，详见章节1中Box类中泛型的使用。
泛型方法
泛型类在多个方法签名间实施类型约束。在 List<V> 中，类型参数 V出现在 get()、add()、contains() 等方法的签名中。当创建一个 Map<K, V> 类型的变量时，您就在方法之间宣称一个类型约束。您传递给 add() 的值将与 get() 返回的值的类型相同。
类似地，之所以声明泛型方法，一般是因为您想要在该方法的多个参数之间宣称一个类型约束。举例如下：

public static void main(String[] args) throws ClassNotFoundException {  
       String str=get("Hello", "World");  
       System.out.println(str);  
}  
public static <T, U> T get(T t, U u) {  
       if (u != null)  
            return t;  
       else  
            return null;  
}  

泛型变量
在泛型类、泛型方法的介绍中，我们已经使用到了泛型变量，申明泛型变量主要是因为我们在定义泛型变量的时候，我们并不知道这个泛型类型T，到底是什么类型，所以，只能默认T为原始类型Object，而是使用时确定泛型T的具体类型，也是用来做类型限定的。
通配符
通配泛型的使用相对基本的泛型类型的使用而言具有一定的难度，不过通配符可以提高API的灵活性。举例如下定义3个类：

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}

通过通配泛型，可以定义出受检的泛型类型，也能够将几个类的关系体现出来。

List<? extends Fruit> flist = new ArrayList<Fruit>();
List<? extends Fruit> flist = new ArrayList<Apple>();
List<? extends Fruit> flist = new ArrayList<Orange>();

3、数组与泛型

数组与泛型相比，有两个重要的不同点。首先，数组是协变的（covariant）。这就是说如果sub是super的子类型，那么数组类型sub[]就是super[]的子类型。然而，泛型是不可变的（invariant），对于任意两个不同的类型type1和type2，List<type1>既不是List<type1>的子类型，也不是List<type2>的超类型。

数组和泛型的第二大区别在于数组是具体化的，因此数组会在运行时才知道并检查他们的元素类型约束。相比之下，泛型是通过擦除来实现的，因此泛型只在编译时强化他们的类型信息，并在运行时丢弃他们的元素类型信息。

Object[] arr = new Long[1];
arr[0] = "I don't fit in"; //运行失败，抛出ArrayStoreException

List<Object> list = new ArrayList<>(); //编译不通过，类型不匹配
list.add(I don't fit in);

（Effective Java第25条：列表优先于数组）
由于以上这些根本的区别，数组和泛型不能很好的混合使用，例如：创建泛型或者类型参数的数组是非法的。

4、类型擦除

不同的语言在实现泛型时采用的方式不同，C++的模板会在编译时根据参数类型的不同生成不同的代码，而Java的泛型是一种伪泛型，编译为字节码时参数类型会在代码中被擦除，单独记录在Class文件的attributes域，而在使用泛型处做类型检查与类型转换。
TIPS: 区别Java语言的编译时和运行时是非常重要的，泛型只在编译时强化他们的类型信息，并在运行时丢弃他们的元素类型信息。泛型的运行时擦除可以通过Java提供的反射机制进行证明，比如通过反射调用List<String>容器的add()方法，绕过泛型检查，成功插入Integer类型的变量。

假设参数类型的占位符为T，擦除规则如下：

• <T>擦除后变为Obecjt
• <? extends A>擦除后变为A
  *<？ super A>擦除后变为Object

上述擦除规则叫做保留上界。泛型擦除之后保留原始类型。原始类型raw type就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除crased，并使用其限定类型(无限定的变量用Object)替换。

但是要区分原始类型和泛型变量的类型
在调用泛型方法的时候，可以指定泛型，也可以不指定泛型。
在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到Object。
在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

  public class Test2{
      public static void main(String[] args) {
           /**不指定泛型的时候*/
          int i=Test2.add(1, 2); //两参数都是Integer，所以T为Integer类型
          Number f=Test2.add(1 , 1.2);//参数是Integer和Float，取同一父类的最小级Number
          Object o=Test2.add(1, "asd"); //参数是Integer和String，取同一父类的最小级Object
        
          /**指定泛型的时候*/
          int a=Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
          int b=Test2.<Integer>add(1 , 2.2);//编译错误，指定了Integer，不能为Float
          Number c=Test2.<Number>add(1,  2.2);  //指定为Number，所以可以为Integer和Float
     }  

     //这是一个简单的泛型方法
      public static <T> T add(T x,T y){
              return y;
      }  
  }

5、类型擦除的问题和解决方法

Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。
因为种种原因，Java不能实现真正的泛型，只能使用类型擦除来实现伪泛型，这样虽然不会有类型膨胀的问题，但是也引起了许多新的问题。所以，Sun对这些问题作出了许多限制，避免我们犯各种错误。
1、先检查，在编译，以及检查编译的对象和引用传递的问题

2、自动类型转换
因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？实际上，使用泛型的容器会在return之前，会根据泛型变量进行强转。

3、类型擦除与多态的冲突和解决方法
子类实现父类中的泛型的方法时注意因为擦除而引起的语义的变化

4、泛型类型变量不能是基本数据类型
不能用类型参数替换基本类型。就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类型变为Object，但是Object类型不能存储double值，只能引用Double的值。

5、运行时类型查询
由于运行时类型已经擦除，所以进行泛型类型的查询是不正确的，对泛型的类型查询Java限定了这种类型查询的方式if( arrayList instanceof ArrayList<?>)

6、异常中使用泛型的问题
不能抛出也不能捕获泛型类的对象。因为异常都是在运行时捕获和抛出的，而在编译的时候，泛型信息全都会被擦除掉，类型信息被擦除后，那么很有可能两个地方的catch都变为原始类型Object，这个当然就是不行的。就好比，catch两个一模一样的普通异常，不能通过编译一样。
根据异常捕获的原则，一定是子类在前面，父类在后面，那么上面就违背了这个原则。即使你在使用该静态方法的使用T是ArrayIndexOutofBounds，在编译之后还是会变成Throwable，ArrayIndexOutofBounds是IndexOutofBounds的子类，违背了异常捕获的原则。所以Java为了避免这样的情况，禁止在catch子句中使用泛型变量。

7、泛型类型的实例化
不能实例化泛型类型

8、类型擦除后的冲突
当泛型类型被擦除后，创建条件不能产生冲突，如下代码段中泛型擦除后方法
boolean equals(T)变成了方法boolean equals(Object)这与Object.equals方法是冲突的！当然，补救的办法是重新命名引发错误的方法。

class Pair<T>   {  
    public boolean equals(T value) {  
        return null;  
    }      
}  

9、泛型在静态方法和静态类中的问题
泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数。因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。但是要注意区分一种情况，在泛型方法中使用的T是自己在方法中定义的T，而不是泛型类中的T，是没有错误的。

public class Test2<T> {    
    public static T one;   //编译错误    
    public static  T show(T one){ //编译错误    
        return null;    
    }    
    public static <T>T show(T one){//这是正确的    
        return null;    
    } 
}  

参考资料：

[1]:《Effective Java》
[2]:关于Java泛型深入理解小总结
[3]:Java泛型详解
[4]:Java泛型的实现：原理与问题
[5]:Java中的逆变与协变
[6]:java泛型（一）、泛型的基本介绍和使用
[7]:java泛型（二）、泛型的内部原理：类型擦除以及类型擦除带来的问题