前言

在Java中，从JDK1.5开始，就引入了泛型，不过经常都能听到一个词：“泛型擦除”，这是什么情况？经过了解发现，原来Java中的泛型严格来说属于“伪泛型”。Java的泛型并不是一直贯穿代码从编译到运行整个阶段的，它仅仅在编译阶段起了作用，编译之后的代码泛型就直接被干掉了，取而代之的是一个通用的Object类型，这个Object类型参与后续的整个运行阶段。

试验

这里可以验证这一个效果，如果泛型不是被擦除的话，严格来说下面这个equals比较结果应该是false，但实际上却是true：

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass().equals(list2.getClass())); //true

这就说名在运行阶段，list1和list2在类型上其实是完全一样的。

思考

因为这种泛型擦除的机制，就考虑到了一个问题：在Java中面向对象的三大特征上有一个就是多态，那么对于这种带有泛型的方法重载它是如何实现的？比如：

public class Container<T> {
    private T value;
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

此时创建一个子类继承自Container：

public class DateContainer extends Container<Date> {
    @Override
    public Date getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(Date value) {
        super.setValue(value);
    }
}

这里DateContainer类中泛型是Date类型，因为有泛型擦除，所以在编译后应该编程基础的Object类型，那这种继承之后的重写如何实现的呢？

这里用到了一个idea的功能，查看bytecode：

image.png

注意：使用它之前要确保当前类经过了编译产生了对应的class，否则可能会报错，提示找不到对应class文件。

我这里bytecode打开后是如下的内容：

// class version 52.0 (52)
// access flags 0x21
// signature Lcom/example/demo2/test01/Container<Ljava/util/Date;>;
// declaration: com/example/demo2/test01/DateContainer extends com.example.demo2.test01.Container<java.util.Date>
public class com/example/demo2/test01/DateContainer extends com/example/demo2/test01/Container {

  // compiled from: DateContainer.java

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKESPECIAL com/example/demo2/test01/Container.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Lcom/example/demo2/test01/DateContainer; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public getValue()Ljava/util/Date;
   L0
    LINENUMBER 8 L0
    ALOAD 0
    INVOKESPECIAL com/example/demo2/test01/Container.getValue ()Ljava/lang/Object;
    CHECKCAST java/util/Date
    ARETURN
   L1
    LOCALVARIABLE this Lcom/example/demo2/test01/DateContainer; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public setValue(Ljava/util/Date;)V
    // parameter  value
   L0
    LINENUMBER 13 L0
    ALOAD 0
    ALOAD 1
    INVOKESPECIAL com/example/demo2/test01/Container.setValue (Ljava/lang/Object;)V
   L1
    LINENUMBER 14 L1
    RETURN
   L2
    LOCALVARIABLE this Lcom/example/demo2/test01/DateContainer; L0 L2 0
    LOCALVARIABLE value Ljava/util/Date; L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1041
  public synthetic bridge setValue(Ljava/lang/Object;)V
    // parameter synthetic  value
   L0
    LINENUMBER 5 L0
    ALOAD 0
    ALOAD 1
    CHECKCAST java/util/Date
    INVOKEVIRTUAL com/example/demo2/test01/DateContainer.setValue (Ljava/util/Date;)V
    RETURN
   L1
    LOCALVARIABLE this Lcom/example/demo2/test01/DateContainer; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1041
  public synthetic bridge getValue()Ljava/lang/Object;
   L0
    LINENUMBER 5 L0
    ALOAD 0
    INVOKEVIRTUAL com/example/demo2/test01/DateContainer.getValue ()Ljava/util/Date;
    ARETURN
   L1
    LOCALVARIABLE this Lcom/example/demo2/test01/DateContainer; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
}

这里有个比较有意思的现象，getter和setter方法在本来DateContainer类里面只有一对，但是这个编译后出现了两对。

另外一对getter和setter方法有一些特殊，加了synthetic bridge。这一对“桥”方法的参数就是擦除后的Object类型，只不过在方法内部进行了一次方法调用，调用的就是具体Date类型的getter和setter方法，这就相当于把父类的方法保留下来的同时，又做了一次方法重载，只是参数不一样。

但是这里又有一个问题，以getter方法为例，可以看到两个getter方法一个返回值是Object，另一个是Date，这种重载模式在我们正常编码的时候肯定是不能通过的，从编译器的角度来看，这两个方法的方法签名是一样的，此时编译器就会提示getter方法“already defined”。

但是这种模式在虚拟机中却是可以允许存在的，虚拟机可以通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区别。

泛型中的<T> 和 <?>

既然提到泛型，不得不说明一下这两个的区别：

<T>

这里的<T>多是用来进行泛型的定义，比如常见的定义类的时候：

public class Container<T> {
......
}

这里字母T更多可能只是一个标识意义，有时候可能还会看到其他一些字母：E、K、V等等，这些都是用在泛型的定义中，只不过因为一些约定俗成的规范，普通类的泛型就用T表示，容器类的泛型用E，带有键值对的泛型用K、V表示。

<?>

它主要用在泛型的声明中，比如：

Container<?> container = new Container<>();

这句话实际上和：

Container container = new Container();

效果是一样的，只是说在上面一种写法比较规范，在代码阅读体验上可能更加明朗一些。

共同点

<T> 和 <?> 两者都可以用与泛型的上下界的表示：

public class Container<T extends List> {}
public class Container<T super List> {}

public class Container<? extends List> {}
public class Container<? super List> {}

在这种时候，两者是等价的。