前言
在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：
注意：使用它之前要确保当前类经过了编译产生了对应的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> {}
在这种时候，两者是等价的。
