一、概述：
在解释什么是泛型擦除之前我们得先了解什么是Java泛型。所谓的泛型就是参数化的类型。这就意思着我们可以具体的类型作为一个参数传递给方法、类、接口。
为什么我们需要泛型呢？首先我们都知道在java里，Object就是对象的父类。Object可以引用任何类型的对象。但是这一点会带来类型安全的问题。而泛型的出现就给java带来了类型安全这一项功能。
1、使用泛型有什么好处？
- 保证类型安全，进行编译期错误检查，使代码具有更好的安全性和可读性。
- 不需要进行类型强制转换。
如下程序，如果不使用泛型前，强转结果很容易出错：
public class GenericClient {
public static void main(String[] args) {
// 不使用泛型，集合中传入的值类型不会受到限制
// 存值没有限制，取值就容易出错，容器安全性得不到保障
List list = new ArrayList();
list.add("tom");
list.add(11);
for(Object obj : list){
// 数据取出，需要进行强转，代码可读性和使用性降低
String str = (String) obj;
System.out.println(str);
}
}
}
出现了类型转换错误：
tom
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at com.koo.generic.GenericClient.main(GenericClient.java:22)
如果使用泛型，编译器会进行检查，从而规避已知的类型转换异常：
2、泛型怎么使用
2.1 在类上
class Test<T> {
T obj
Test(T obj){
this.obj = obj;
}
}
2.2 在方法上
class Test {
static <T> void helloworld(T t){
}
}
2.3 在接口上
interface Test<T> {
T getData();
}
二、什么是类型擦除？
1、概念
Java 泛型的实现是在编译层，编译后生成的字节码中不包含泛型中的类型信息。所以使用泛型时，加上的类型参数，会在编译器编译的时候去掉，这个过程称为类型擦除。
2、擦除示例
public static <T> boolean myequal(T t1, T t2){
return t1.equals(t2);
}
编译器会用Object替换掉类型T，如下：
public static <Object> boolean myequal(Object t1, Object t2){
return t1.equals(t2);
}
3、泛型类的类型擦除
在类级别的类型擦除遵循这样的规则：首先编译器丢弃类上的类型参数，并用它的第一个绑定类型替换它，如果类型参数没有绑定，就用Object来替换。
- 参数类型没有绑定
public class MyClass<T> {
private T[] elements;
public void doSomething(T element){
}
public T getSomething(){
}
}
MyClass的类型参数T没有绑定到任何类型，所以将会用Object来替换掉T，替换结果：
public class MyClass {
private Object[] elements;
public void doSomething(Object element){
}
public Object getSomething(){
}
}
- 参数类型有绑定
interface MyT {
}
public class MyClass<T extends MyT> {
private E[] elements;
public void doSomething(T element){
}
public T getSomething(){
}
}
MyTClass是MyClass的类型参数T第一个绑定到的类型，因此T将会被替换成MyTClass：
public class MyClass {
private MyT[] elements;
public void doSomething(MyT element){
}
public MyT getSomething(){
}
}
为什么取第一个绑定就OK了呢？比如说，如果MyT还有父类，父类还有父类，那么我们的类型参数就有了很多间接的绑定，而第一个绑定就覆盖了所有的父类，因此用第一个绑定就可以了。
4、泛型方法的类型擦除
对于泛型方法，它的类型参数不会被存放起来，它遵循这样的规则：首先编译器丢弃方法上的类型参数，并用它的第一个绑定类型替换它，如果类型参数没有绑定，就用Object来替换。
- 参数类型没有绑定
public static <T> void printSomething(T[] arr){
for(T item: arr) {
System.out.printf("%s", item);
}
}
上面的方法，进行类型擦除的结果后：
public static void printSomething(Object[] arr){
for(Object item: arr) {
System.out.printf("%s", item);
}
}
- 参数类型有绑定
public static <T extends MyT> void printSomething(T[] arr){
for(T item: arr) {
System.out.printf("%s", item);
}
}
上面的方法，进行类型擦除的结果后：
public static void printSomething(MyT[] arr){
for(MyT item: arr) {
System.out.printf("%s", item);
}
}
三、类型擦除带来的问题
问题描述：
类型信息被擦除，怎么能保证只使用泛型变量的限定类型？编译后 String是Object，Integer 也是 Object，怎么能确定使用哪一个呢？
1、检查针对引用，而非引用对象
什么是引用？
比如 A a = new A();
此时变量a指向了一个A对象，a被称为引用变量，也可以说a是A对象的一个引用。我们通过操纵引用变量a来操作A对象。变量a的值为它所引用对象的地址。
为确保正确的使用类型，java的实现顺序是这样的：
先检查泛型类型（针对引用）——类型擦除——编译
如图:
类型检查就是编译时完成的。new ArrayList()只是在内存中开辟了一个存储空间，可以存储任何的类型对象。而真正涉及类型检查的是它的引用，因为我们是使用它的引用来调用它的方法，比如说list1调用add()方法，它做了泛型限定，所以list1引用能完成泛型类型的检查。而引用list2没有使用泛型，所以没有进行类型检查。
通过上边的例子，我们可以明白，类型检查就是针对引用的。谁是一个引用，用这个引用调用泛型方法，就会针对这个引用调用的方法进行类型检测，而无关它真正引用的对象。
2、泛型中参数化类型不考虑继承关系
下边情况的引用传递是不被允许的——集合不存在类型之间的继承关系
3、泛型类型变量不能是基本数据类型
不能用类型参数替换基本类型。就比如，没有ArraryList，只有ArraryList。因为当类型擦除后，ArraryList的原始类型变为Object，但是Object类型不能存储double值，只能引用Double的值。
4、运行时类型检查异常——instanceof
例如：
ArrayList<String> arrayList = new ArrayList<String>();
因为类型擦除后，ArrayList只剩下原始类型，泛型信息String不存在了。
所以你不能这样去判断：
if(arrayList instanceof ArrayList<String>){
}
正确的做法是通过通配符的方式：
if(arrayList instanceof ArrayList<?>){
}
源码下载：
https://gitee.com/charlinchenlin/koo-erp