面试官问我：“泛型擦除是什么，会带来什么问题？”

List list = new ArrayList();
List listString = new ArrayList<String>();
List listInteger = new ArrayList<Integer>();

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList();
        List listString = new ArrayList<String>();
        List listInteger = new ArrayList<Integer>();

        try {
            list.getClass().getMethod("add", Object.class).invoke(list, 1);
            listString.getClass().getMethod("add", Object.class).invoke(listString, 1);
            // 给不服气的读者们的测试之处，你可以改成字符串来尝试。
            listInteger.getClass().getMethod("add", Object.class).invoke(listInteger, 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("list size:" + list.size());
        System.out.println("listString size:" + listString.size());
        System.out.println("listInteger size:" + listInteger.size());
    }
}

// 先来看看画了一个大饼的List
// 能够过很清楚的看到泛型E
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{       
    // 第一个关键点    
    // 还没开始就出问题的存储类型
    // 难道不应该也是一个泛型E？
    transient Object[] elementData;


    public E get(int index) {
        rangeCheck(index);

        return elementData(index); // 1---->
    }

    // 由1直接调用的函数
    // 第二个关键点，强制转化得来的数据
    E elementData(int index) {
        return (E) elementData[index];
    }
}

List<String> listObject = new ArrayList<Object>();
List<Object> listObject = new ArrayList<String>();

public class Part<T extends Parent> {

    private T val;

    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }
}

该部分的思路来自于：https://blog.csdn.net/qq_36898043/article/details/79655309

// 承载者
class Plate<T>{
    private T item;
    public Plate(T t){item=t;}
    public void set(T t){item=t;}
    public T get(){return item;}
}

// Lev 1
class Food{}

// Lev 2
class Fruit extends Food{}
class Meat extends Food{}

//Lev 3
class Apple extends Fruit{}
class Banana extends Fruit{}
class Pork extends Meat{}
class Beef extends Meat{}

//Lev 4
class RedApple extends Apple{}
class GreenApple extends Apple{}

Plate<? extends Fruit> p1=new Plate<Apple>(new Apple());
Plate<? extends Fruit> p2=new Plate<Apple>(new Beef()); // 检查不通过

// 修改数据不通过
p1.set(new Banana());

// 数据获取一切正常
// 但是他只能精确到由我们定义的Fruit
Fruit result = p1.get();

// 填写Food的位置，级别一定要大于或等于Fruit
Plate<? super Fruit> p1=new Plate<Food>(new Apple());
// 和extends 不同可以进行存储
p1.set(new Banana());
// get方法
Banana result1 = p1.get(); // 会报错，一定要经过强制转化，因为返回的只是一个Object
Object result2 = p1.get(); // 返回一个Object数据我们已经属于快要丢失掉全部数据了，所以不适合读取

从百度上只要这样输入关键词，java 逆变与协变 你就能得到类似与下方文字的统一解。

// 协变
List<? extends Fruit> fruit = new ArrayList<Apple>();
// 逆变
List<? super Apple> fruit = new ArrayList<Fruit>();
// 不变
List<Apple> fruit = new ArrayList<Apple>();

List list = new ArrayList();
List<Fruit> flist = new ArrayList<Apple>(); // 为了让这样的形式成立，有了我们下方的代码
List<? extends Fruit> fruitList = new ArrayList<Apple>();

List list =(List) new ArrayList();
List<Fruit> fruit = (ArrayList<Fruit>)new ArrayList<Apple>(); // 依旧编译错误，同理引进了super
List<? super Apple> fruit1 = new ArrayList<Fruit>();

List<Apple> list = new ArrayList<Apple>();

public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return ArrayList.this.elementData(offset + index); // 1 -->
        }

E elementData(int index) {
        return (E) elementData[index];
    }

List<? extends Fruit> fruits = new ArrayList<Apple>();
fruits.add(new Apple());  // 编译报错
fruits.add(new Fruit());  // 编译报错
fruits.add(new Object());  // 编译报错

List<? super Apple> apples = new ArrayList<Fruit>();
apples.add(new Apple());
apples.add(new Jonathan());
apples.add(new Fruit());  // 编译错误

List<? extends Fruit> fruits = new ArrayList<Apple>();
Apple apple = fruits.get(0);
Jonathan jonathan = fruits.get(0);  // 编译错误
Fruit fruit = fruits.get(0);

List<? super Apple> apples = new ArrayList<Fruit>();
Object jonathan = apples.get(0);
// 其余只能通过强制转化获得

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }