Java泛型－类型擦除

1、概述

      Java泛型在使用过程有诸多的问题，如不存在List<String>.class, List<Integer>不能赋值给List<Number>（不可协变），奇怪的ClassCastException等。 正确的使用Java泛型须要深刻的了解Java的一些概念，如协变，桥接方法，以及这篇笔记记录的类型擦除。Java泛型的处理几乎都在编译器中进行，编译器生成的bytecode是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。

2、编译器如何处理泛型？

     一般状况下，一个编译器处理泛型有两种方式：
     1.Code specialization。在实例化一个泛型类或泛型方法时都产生一份新的目标代码（字节码or二进制代码）。例如，针对一个泛型list，可能须要 针对string，integer，float产生三份目标代码。
     2.Code sharing。对每一个泛型类只生成惟一的一份目标代码；该泛型类的全部实例都映射到这份目标代码上，在须要的时候执行类型检查和类型转换。
     C++中的模板（template）是典型的Code specialization实现。C++编译器会为每个泛型类实例生成一份执行代码。执行代码中integer list和string list是两种不一样的类型。这样会致使代码膨胀（code bloat），不过有经验的C＋＋程序员能够有技巧的避免代码膨胀。
     Code specialization另一个弊端是在引用类型系统中，浪费空间，由于引用类型集合中元素本质上都是一个指针。不必为每一个类型都产生一份执行代码。而这也是Java编译器中采用Code sharing方式处理泛型的主要缘由。
     Java编译器经过Code sharing方式为每一个泛型类型建立惟一的字节码表示，而且将该泛型类型的实例都映射到这个惟一的字节码表示上。将多种泛型类形实例映射到惟一的字节码表示是经过类型擦除（type erasue）实现的。

3、 什么是类型擦除？

     类型擦除指的是经过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，而且再必要的时候添加类型检查和类型转换的方法。
     类型擦除能够简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
     类型擦除的主要过程以下：
     1.将全部的泛型参数用其最左边界（最顶级的父类型）类型替换。
     2.移除全部的类型参数。
     如

interface Comparable <A> { 
  public int compareTo( A that); 
} 
final class NumericValue implements Comparable <NumericValue> { 
  priva te byte value;  
  public  NumericValue (byte value) { this.value = value; }  
  public  byte getValue() { return value; }  
  public  int compareTo( NumericValue t hat) { return this.value - that.value; } 
} 
－－－－－－－－－－－－－－－－－
class Collections {  
  public static <A extends Comparable<A>>A max(Collection <A> xs) { 
    Iterator <A> xi = xs.iterator(); 
    A w = xi.next(); 
    while (xi.hasNext()) { 
      A x = xi.next(); 
      if (w.compareTo(x) < 0) w = x; 
    } 
    return w; 
  } 
} 
final class Test { 
  public static void main (String[ ] args) { 
    LinkedList <NumericValue> numberList = new LinkedList <NumericValue> (); 
    numberList .add(new NumericValue((byte)0));  
    numberList .add(new NumericValue((byte)1));  
    NumericValue y = Collections.max( numberList );  
  } 
}

通过类型擦除后的类型为

interface Comparable {
  public int compareTo( Object that); 
} 
final class NumericValue implements Comparable { 
  priva te byte value;  
  public  NumericValue (byte value) { this.value = value; }  
  public  byte getValue() { return value; }  
  public  int compareTo( NumericValue t hat)   { return this.value - that.value; } 
  public  int compareTo(Object that) { return this.compareTo((NumericValue)that);  } 
} 
－－－－－－－－－－－－－
class Collections {  
  public static Comparable max(Collection xs) { 
    Iterator xi = xs.iterator(); 
    Comparable w = (Comparable) xi.next(); 
    while (xi.hasNext()) { 
      Comparable x = (Comparable) xi.next(); 
      if (w.compareTo(x) < 0) w = x; 
    } 
    return w; 
  } 
} 
final class Test { 
  public static void main (String[ ] args) { 
    LinkedList numberList = new LinkedList(); 
    numberList .add(new NumericValue((byte)0));  ，
    numberList .add(new NumericValue((byte)1));  
    NumericValue y = (NumericValue) Collections.max( numberList );  
  } 
}

第一个泛型类Comparable <A>擦除后 A被替换为最左边界Object。Comparable<NumericValue>的类型参数NumericValue被擦除掉，可是这直 接致使NumericValue没有实现接口Comparable的compareTo(Object that)方法，因而编译器充当好人，添加了一个桥接方法。
第二个示例中限定了类型参数的边界<A extends Comparable<A>>A，A必须为Comparable<A>的子类，按照类型擦除的过程，先讲全部的类型参数 ti换为最左边界Comparable<A>，而后去掉参数类型A，获得最终的擦除后结果。

4、类型擦除带来的问题

     正是因为类型擦除的隐蔽存在，直接致使了众多的泛型灵异问题。
 Q1.用同一泛型类的不一样实例区分方法签名？——NO！

     public class Erasure{

            public void test(List<String> ls){
                System.out.println("Sting");
            }
            public void test(List<Integer> li){
                System.out.println("Integer");
            }
    }

编译器会报错，由于类型擦除后jvm就区分不了这个方法了

Q2. 同时catch同一个泛型异常类的多个实例？——NO！
同理，若是定义了一个泛型一场类GenericException<T>，千万别同时catch GenericException<Integer>和GenericException<String>，

由于对于jvm来讲他们是同样的。
Q3.泛型类的静态变量是共享的？——Yes！
猜猜这段代码的输出是什么？

import java.util.*;

public class StaticTest{
    public static void main(String[] args){
        GT<Integer> gti = new GT<Integer>();
        gti.var=1;
        GT<String> gts = new GT<String>();
        gts.var=2;
        System.out.println(gti.var);
    }
}
class GT<T>{
    public static int var=0;
    public void nothing(T x){}
}

输出是——2！因为通过类型擦除，全部的泛型类实例都关联到同一份字节码上，泛型类的全部静态变量是共享

的。

Q4.泛型之间不存在继承关系！

方法f（List<Object>）不能接收类型为List<String>的参数。

能够再抽象出一个中间层（ <?   extends  Parent > ）来解决 方法f(List<? extends Object>)就能够接收List<String>

参数了。

5、Just remember

1.虚拟机中没有泛型，只有普通类和普通方法
2.全部泛型类的类型参数在编译时都会被擦除
3.不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你

6、编码规则

Effective Java，第23条：请不要在新代码中使用原生态类型

声明中具备一个或者多个类型参数（type parameter）的类或者接口，就是泛型（ generic）类或者接口。

泛型类和泛型接口统称为泛型（ generic type）。

每种泛型均可以定义一组参数化的类型（parameterized type）,构成格式：类（接口）名<参数类型>。

每种泛型都定义一个原生态类型（raw type），即不带任何实际类型参数的泛型名称。

若是使用原生态类型，就失掉了泛型在安全性和表述性方面的全部优点。

出错以后应该尽快发现，最好是在编译时就发现。

一、使用泛型后，能够很快的发现错误。

二、使用泛型后，不须要进行手工转换了。以下代码：

若是不提供参数类型，使用集合类型和其余泛型也仍然是合法的，但不该该这么作。若是使用原生态类型，就失掉了泛型在安全性和表述性方面的全部优点。

原生态类型List和参数化类型List<Object>之间有什么区别？

前者逃避了泛型检查，后者则明确告知编译器，它可以持有任意类型的对象。

你能够将List<String>传递给类型List的参数 却不能传递给类型List<Object>的参数。由于，泛型有子类型化的规则，List<String>是原生态类型List的一个子类型，而不是参数化类型List<Object>的子类型（见第25条）。

若是使用像List这样的原生类型，就会失掉类型安全性，可是若是使用像List<Object>这样的参数化类型，则不会。

那若是遇到不肯定元素类型的时候该怎么办？

这种状况是可使用原生态类型，可是很危险。在Java1.5开始，提供了一个安全的替代方法，无限制的通配符（unbounded wildcard type）。如：Set<?>。

有两种状况可使用原生态类型。

一、在类文字（class literal）中必须使用原生态类型。也就是说List.class,String[].class和int.class是合法的，可是List<String>.class和List<?>.class是非法的。

二、与instanceof操做符有关。因为泛型信息能够在运行时被擦除，所以在参数化类型而非无限制通配符类型上使用instanceof操做符是非法的。

下面是利用泛型来使用instanceof操做符的首选方法：

if(o instanceof Set){

Set<?> m=(Set<?>)o;

}

注意：一旦肯定这个o是个Set，就必须将它转换成通配符类型Set<?>再用Set<?>作后续操做。由于不加？就能够add，若是add进去的对象的类型不是否是当初定义的类型别人来用的类型的时候就会有安全性问题。

检讨的？暂时了解的不透彻等有机会用的时候再了解吧。具体用的再理解吧，像这种应用类型的知识没有场景不能凭空想一想，而像一些基础的只是没有场景也能学会应为遇到到太多的类似的东西了那个概念太熟了，熟了或者基础知识的体系太成熟了有点像数学上的公理不须要场景。