【android学习】泛型通配符extends与super区别

泛型关键字说明

• <? extends T>：是指 “上界通配符”  ?>=T
• <? super T>：是指 ”下界通配符“  ?<=T

类型结构图

在类中 extends 与 super对比

• ?所代表得类，是Meat得父类   即?>=Meat ，本例中？这里可以代表为Meat，Food这两种类型

    补充： 出错的两句的？这里，泛型要求传入Meat，Food类型，但是传入的确实Chicken，Pock，所以出错。

     //只能放meat以及meat得父类  ?>=Meat 
        Plate<? super Meat> plate21 = new Plate<>(new Meat());
        Plate<? super Meat> plate22 = new Plate<>(new Food());
     //存放meat得子类chicken以及pock就会报错
     //Plate<? super Meat> plate23 = new Plate<>(new Chicken()); //会出错
     //Plate<? super Meat> plate24 = new Plate<>(new Pock());//会出错

•  ?所代表得类，是Meat得子类   即?<=Meat ，本例中的？可以代表为Meat，Chicken，Pock这三种类型

        补充：出错的这句的？这里，泛型要求传入Meat，Food类型，但是传入的确实Chicken，Pock，所以出错。

      //只能存放meat以及meat得子类  ?<=Meat
        Plate<? extends Meat> plate31 = new Plate<>(new Meat());
        Plate<? extends Meat> plate32 = new Plate<>(new Chicken());
        Plate<? extends Meat> plate33 = new Plate<>(new Pock());
      //存放meate得父类food就会报错
      //Plate<? extends Meat> plate34 = new Plate<>(new Food());//会报错

在List中extends与super对比

• ?所代表得类，是Meat得父类   即?>=Meat ，本例中？这里可以代表为Meat，Food这两种类型

      补充：出错的两句的？这里，泛型要求传入Meat，Food类型，但是传入的确实Chicken，Pock，所以出错。

        List<? super Meat> list21 = new ArrayList<Food>();
        List<? super Meat> list22 = new ArrayList<Meat>();
        //List<? super Meat> list23 = new ArrayList<Chicken>(); //会出错
        //List<? super Meat> list24 = new ArrayList<Pock>(); //会出错

• ?所代表得类，是Meat得子类   即?<=Meat ，本例中的？可以代表为Meat，Chicken，Pock这三种类型

        补充：出错的这句的？这里，泛型要求传入Meat，Food类型，但是传入的确实Chicken，Pock，所以出错。

        //只能存放meat以及meat得子类  <=
        List<? extends Meat> list31 = new ArrayList<Meat>();
        List<? extends Meat> list32 = new ArrayList<Chicken>();
        List<? extends Meat> list33 = new ArrayList<Pock>();
        //存放meate得父类food就会报错
        //List<? extends Meat> list34 = new ArrayList<Food>();//会报错

在List中的add方法，extends与super对比

• ?所代表得类，是Meat得父类   即?>=Meat ，本例中？这里可以代表为Meat，Food这两种类型

      补充：看到这里就会很奇怪，为啥list21.add(new Food())会报错

      原因：这里?>=Meat，我们取最小值那就是Meat，就将？换成Meat，就能明白了(具体可以通过下面ArrayList源码分析)

        List<? super Meat> list21 = new ArrayList<>();
        //list存放meat以及meat得子类 <=
        list21.add(new Meat());
        list21.add(new Chicken());
        list21.add(new Pock());
        //list不能存放meat得父类
        //list21.add(new Food());//会报错

•  ?所代表得类，是Meat得子类   即?<=Meat ，本例中的？可以代表为Meat，Chicken，Pock这三种类型

       补充：看到这里就会很奇怪，为啥都报错

      原因：这里?<=Meat，我们取最小值并不知道是哪一个，所以就没有办法添加数据了(具体可以通过下面ArrayList源码分析)

        List<? extends Meat> list31 = new ArrayList<>();
        //list31.add(new Meat());//会报错
        //list31.add(new Food());//会报错
        //list31.add(new Chicken());//会报错
        //list31.add(new Pock());//会报错

  我们通过ArrayList中的add源码来分析这个问题，这里添加的 E 是一个泛型，所以

• 在使用List<? super Meat>（?>=Meat ）  创建ArrayList时候，它并不知道你会传入会是Meat还是Food，就会出现两种可能List<Meat> list21 ；List<Food> list21;为了兼容两者可能，所以，此时的List<? super Meat>就必须同时满足Meat和Food的可能，也就相当于List<? super Meat>，所以添加的list21.add(new Food())//会报错
• 在使用List<? extends Meat>（?<=Meat ）创建ArrayList时候，它并不知道你会传入会是Meat，Chicken还是Pock，就会出现两种可能List<Meat> list31 ; List<Chicken> list31 ;List<Pock> list31 ;为了兼容三者可能，所以，此时的List<? super Meat>中的？就必须同时满足Meat，Chicken还是Pock三者的可能，所以添加的四个都会报错

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

在List中的get方法，extends与super对比

• ?所代表得类，是Meat得父类   即?>=Meat ，所有的对象的父类都是Object，所以这里也就能理解

List<? super Meat> list21 = new ArrayList<Food>();
Object object21 = list21.get(0);

•   ?所代表得类，是Meat得子类   即?<=Meat ，所以这里所有对象，都会是Meat的子类

List<? extends Meat> list31 = new ArrayList<>();
Meat meat = list31.get(0);

这里得到添加进去的方法，因为可以强制转换，所以就不在累赘了