Java中 ? extends E 和 ？super E 的区别

问题:? extends E 和 ？super E的区别：

在说明这个问题之前,先来解释一下有关泛型的几个问题？

1>、在创建集合对象的时候,要保证前后的泛型一致,如果不一致编译时会出错。例如：

List<Object> list = new ArrayList<String>();  //编译时会出错。

a、首先：String 是 Object 的子类

b、其次：ArrayList 是 List 的子类

c、但是：ArrayList<String> 不是 List<Object>的子类

问题说明：

List<E> 和 ArrayList<E> 是可以操作任意数据类型的,所以只能使用泛型来让使用者在创建对象的时候确定,该集合操作的是什么数据类型。

1、List是接口,所以实现类要把接口中的抽象方法全部重写。在重写的时候父类中的方法的时候,操作的数据类型也是要与父类保持一致的。

  所以父类和子类操作的都是泛型E(此时还不确定具体操作的是什么数据类型,有使用者确定)

2、举例说明：

第一种情况：
interface Animal<E>{
public void show(E e);
}


class Dog<E> implements Animal<E>{


@Override
public void show(E e) {
System.out.println(e);
}
}

这个案例和我们集合中的情况是一致的。

如果创建对象如下：
Animal<Object> a = new Dog<String>();  //会在编译时会出错。


第二种情况：有些童鞋有这样的想法
interface Animal<E>{
public void show(E e);
}


class Dog<E,String> implements Animal<E>{ //在继承父类(接口)的泛型,我子类可以有自己的数据类型。这样写本身是没有问题的。
//但是又有什么卵用呢？
@Override
public void show(E e) { //这个方法是重写父类中的方法,该方法本身没有问题
System.out.println(e);
}

public void show(String str) { //那我想在重写父类中的show()方法之后,在重载该方法。这样就是不允许的
System.out.println(e); //因为此时虽然并没有确定E是什么数据类型,但是E可以是任意的数据类型,也就是说E也可以是String类型
} //那么,你这个方法就有问题了。在一个类中,是不允许有两个一模一样的方法的。
}

但是：
Animal<Object> a = new Dog<Object,String>();//这样创建对象是没有问题的。
Animal<String> a = new Dog<String,String>();//也可以这样


第三种情况：有些童鞋为了能够把对象创建成功,是这样写的：

interface Animal<E>{
public void show(E e);
}


class Dog<String> implements Animal<Object>{
@Override
public void show(Object obj) {
System.out.println(obj);
}
}

这样写语法上没有太大的问题,但是这已经失去了泛型的意义。可以添加任意的数据类型,对操作的数据已经没有限制作用。
Animal<Object> a = new Dog<String>();这样创建对象也是没有问题的。

还有几种情况,就不列举了。这些就已经能够说明问题了。

问题总结：

好,言归正传。通过以上的案例,也许有些童鞋已经明白了。不过我还是要谈一下自己的理解;

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

我们规定了List集合中的泛型是Object,那么List中所有使用的到该泛型的都已经是Object类型的数据了。那么实现类中重写的方法,此时

也已经确定了这个数据类型,而但你在new ArrayList<String>();对象的时候,又把实现类中的泛型改为了String类型。

1、子类无法重写父类中的方法。

2、子类和父类操作的数据类型不一致(当然如果父类操作的是String类型,那么子父类是一致的。但是,这只是其中的一种情况)


2>、关于通配符（?）的问题

创建对象如下：
List<?> list = new ArrayList<String>();

这样创建对象,没有语法问题的。编译的时候可以通过。但是如何做添加的操作。其实问题和上面的是一样的。

在你添加的时候,你的数据类型是不确定的。

如果不能明确你要添加的是什么数据类型的话,是不允许你做添加操作的,因为他要和后面ArrayList<String>泛型做对比,看

是否操作的是同一种数据类型。



一、？ extends E 向上限定，E及其子类(泛型固定上边界)

举例说明：

目前有三个类，Person类、Student类、Teacher类。

三个类之间的关系：
Student类、Teacher类都继承了Person类

1>、在创建集合对象的时候
List<? extends Person> list = new ArrayList<Person>();

当你做添加操作的时候,会出现：list.add(null e);这样是不允许的。

因为：
List<? extends Person> list = new ArrayList<Student>();
List<? extends Person> list = new ArrayList<Teacher>();
在你创建这两个对象也是合法的。

虽然你的泛型固定了上边界,但是你是无法确定你的子类是什么具体的类型,你也没法确定你子类的个数。

你不可能把你的父类添加到你的子类中。

其实,不能添加的主要原因和一开始我们讲的第一个问题是一样的。

如果：
List<? extends Person> list = new ArrayList<Student>();

可以让你添加元素

那么：
list.add(new Person());这样是可以添加进去的。

但是你把父类的Person对象,添加到了你的Student子类中了。

也可以这样做：list.add(new Teacher());  所以不成了。


问题总结：

1、？ extends E 名为：向上限定，？代表E及其子类，也可以称之为：泛型固定上边界;

2、当创建集合对象,List<? extends Person> list = new ArrayList<Person>();不能做添加操作,以及其他相关的操作
  
  原因：是在你做添加操作的时候,你只知道,你添加数据的上限。但是你无法确定你要添加数据的下限。
  
当你做添加操作的时候,确定你具体添加的是什么类型,子类重写的方法,也必须是该类型的或者该类型的子类。
 
但是，如果你添加的类型,和你的对象(例如：new ArrayList<Person>())中的类型不匹配,在实际操作中是有问题的。
 
故而为了避免这种问题(类型转换异常)，干脆不让你操作。
 
3、但是 ？super E 向下限定，E及其父类(泛型固定下边界)在做添加的时候是不会有问题的。

因为：你泛型的下边界,已经限制。再向集合中添加数据,只能是期本身或者他的子类。

List<? super Person> list = new ArrayList<Person>();

在此只能添加 Person对象，已经Person的子类。



2>、这是第二种情况,有些童鞋也许有疑惑就是,在我们使用集合的是有一个方法是：addAll(Collection<? extends E> c) 

a、首先该方法中添加的是集合对象,而且该集合对象必须是Collection或者他的子类(子接口,或者实现类)

b、? extends E 限定的是,所添加集合的泛型是什么数据类型。

c、该功能的作用是讲传入集合中的每一个元素，添加到调用集合中。

举例说明：

创建第一个集合对象：
List<Person> list = new ArrayList<>();

创建第二个集合对象：
ArrayList<Student> alist = new  ArrayList<>();

问题：你可以把 alist集合对象添加到list集合中,但是反之则不可以？

问题解答：
在集合对象,使用addAll(Collection<? extends E> c)方法的是,对集合本身的限制：只要是属于Collection集合的子类或者其本身,都可以相互添加。当然你不能添加一个Map集合。

限制的其实还是,集合中的元素。你可以把子类添加到父类中(多态),但你绝不可以把父类添加到子类中(没有这种实现方法)。



二、？super E 向下限定，E及其父类(泛型固定下边界)

举例说明：

目前有四个类，Person类、Student类、Teacher类、GoodStudent类。

四个类之间的关系：
Student类、Teacher类都继承了Person类
GoodStudent类继承于Student类


1> 其实,第一种情况:上面已经说过了,在这就不再都说了。 看 ？ extends E 中的第一种情况的最后总结的第3问。





2> 在我们学习TreeSet或者TreeMap的时候,我们可以使用比较器排序。需要在TreeSet或者TreeMap中的构造方法中,传入Comparator的子类对象。

  用TreeSet举例：TreeSet(Comparator<? super E> comparator) 
  
  代码案例如下：
  
第一种情况：


TreeSet<Student> ts = new TreeSet<>(new Comparator<Person>() {


@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
});

ts.add(new GoodStudent("zs",23));
ts.add(new GoodStudent("ls",24));
ts.add(new Student("ww",25));
System.out.println(ts);

a、TreeSet<Student>该泛型规定了,你要添加的元素数据类型,必须是Student类以及其子类。

b、Comparator<Person>该泛型规定了,作为比较的数据类型,必须是Student类或者其父类。

c、你可以把子类放在其父类中进行排序,但是反之则不可以。


第二种情况：
TreeSet<Person> ts = new TreeSet<>(new Comparator<Person>() {


@Override
public int compare(Person p1, Person p2) {
return p2.getAge() - p1.getAge();
}
});

ts.add(new GoodStudent("zs",23));
ts.add(new GoodStudent("ls",24));
ts.add(new Student("ww",25));
ts.add(new Teacher("zl",26));
System.out.println(ts);


a、TreeSet<Person> 和 Comparator<Person>数据类型一致的时候,比较的范围会增大,可以加入Person对象,其实原理和上面是一样的。

问题总结：

？super E：无论放在什么地方进行使用,他已经把下边界给固定了,你在进行比较数据的或者其他操作时候,只能是他本身或者他的子类。不可以是

他的父类。

作为比较器中使用,你可以把子类放在父类中进行比较。


以上纯属个人见解,如有问题,望及时纠正！