java和java有什么区别？超级E>和<？扩展E>？

Question

<? super E>和<? extends E>之间有什么区别

例如，当您查看类java.util.concurrent.LinkedBlockingQueue时，构造函数有以下签名：

public LinkedBlockingQueue(Collection<? extends E> c)

其中一种方法是：

public int drainTo(Collection<? super E> c)

Answer 1

<? extends E>将E定义为上限：“这可以转换为E”

<? super E>将E定义为下限：“E可以被强制转换为这个。”

Answer 2

你可以want to google for the terms反方差（<? super E>）和协方差（<? extends E>）。我发现理解泛型时最有用的事情是理解Collection.addAll的方法签名：

public interface Collection<T> {
    public boolean addAll(Collection<? extends T> c);
}

正如您希望能够将String添加到List<Object>：

List<Object> lo = ...
lo.add("Hello")

您还应该能够通过addAll方法添加List<String>（或任何String的集合）：

List<String> ls = ...
lo.addAll(ls)

然而，你应该意识到aList<Object>和aList<String>不是等价的，后者也不是前者的子类。需要的是协变类型参数的概念，即<? extends T>位

一旦你有了这一点，你就可以很容易地想到你想要相反的场景（查看Comparable界面）

Answer 3

我要试着回答这个问题。但要想得到一个真正好的答案，你应该看看Joshua Bloch的书《有效的Java》（第二版）。他描述了助记符PEC，它代表“生产者延伸，消费者超级”

其思想是，如果代码使用的是来自对象的泛型值，那么应该使用extends。但如果要为泛型类型生成新值，则应使用super

例如：

public void pushAll(Iterable<? extends E> src) {
  for (E e: src) 
    push(e);
}

及

public void popAll(Collection<? super E> dst) {
  while (!isEmpty())
    dst.add(pop())
}

但你真的应该看看这本书： http://java.sun.com/docs/books/effective/

Answer 4

<? super E>表示any object including E that is parent of E

<? extends E>表示any object including E that is child of E .

Answer 5

其原因基于Java实现泛型的方式

一个数组示例

使用数组可以做到这一点（数组是协变的）

Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;

但是，如果你尝试这样做会发生什么

myNumber[0] = 3.14; //attempt of heap pollution

最后这一行可以很好地编译，但如果运行这段代码，可能会得到一个ArrayStoreException。因为您试图将一个double放入一个整数数组（不管通过数字引用访问）

这意味着您可以愚弄编译器，但不能愚弄运行时类型系统。这是因为数组是我们所说的可重定义类型。这意味着在运行时Java知道这个数组实际上被实例化为一个整数数组，而这个数组恰好是通过Number[]类型的引用访问的

正如你所见，一件事是对象的实际类型，另一件事是你用来访问它的引用类型，对吗

Java泛型的问题

现在，Java泛型类型的问题是类型信息被编译器丢弃，并且在运行时不可用。这个过程叫做type erasure。在Java中实现这样的泛型有很好的理由，但这是一个很长的故事，它必须做到与已有代码的二进制兼容性（参见How we got the generics we have）

但这里重要的一点是，因为在运行时没有类型信息，所以无法确保我们没有造成堆污染

比如

List<Integer> myInts = new ArrayList<Integer>();
myInts.add(1);
myInts.add(2);

List<Number> myNums = myInts; //compiler error
myNums.add(3.14); //heap pollution

如果Java编译器没有阻止您这样做，那么运行时类型系统也无法阻止您，因为在运行时，无法确定该列表仅应为整数列表。Java运行时将允许您在这个列表中放入任何您想要的内容，而它应该只包含整数，因为当它被创建时，它被声明为一个整数列表

因此，Java的设计者确保你不能愚弄编译器。如果你不能愚弄编译器（就像我们可以愚弄数组一样），你也不能愚弄运行时类型系统

因此，我们说泛型类型是不可重定义的

显然，这会妨碍多态性。考虑下面的例子：

static long sum(Number[] numbers) {
   long summation = 0;
   for(Number number : numbers) {
      summation += number.longValue();
   }
   return summation;
}

现在你可以这样使用它：

Integer[] myInts = {1,2,3,4,5};
Long[] myLongs = {1L, 2L, 3L, 4L, 5L};
Double[] myDoubles = {1.0, 2.0, 3.0, 4.0, 5.0};

System.out.println(sum(myInts));
System.out.println(sum(myLongs));
System.out.println(sum(myDoubles));

但是，如果试图用泛型集合实现相同的代码，则不会成功：

static long sum(List<Number> numbers) {
   long summation = 0;
   for(Number number : numbers) {
      summation += number.longValue();
   }
   return summation;
}

如果你试图

List<Integer> myInts = asList(1,2,3,4,5);
List<Long> myLongs = asList(1L, 2L, 3L, 4L, 5L);
List<Double> myDoubles = asList(1.0, 2.0, 3.0, 4.0, 5.0);

System.out.println(sum(myInts)); //compiler error
System.out.println(sum(myLongs)); //compiler error
System.out.println(sum(myDoubles)); //compiler error

解决方案是学习使用Java泛型的两个强大特性，即协方差和逆变

协方差

有了协方差，你可以从一个结构中读取项目，但你不能在其中写入任何内容。所有这些都是有效的声明

List<? extends Number> myNums = new ArrayList<Integer>();
List<? extends Number> myNums = new ArrayList<Float>();
List<? extends Number> myNums = new ArrayList<Double>();

你可以从myNums读到：

Number n = myNums.get(0); 

因为你可以确定，不管实际列表包含什么，它都可以被升级为一个数字（毕竟任何扩展数字的东西都是一个数字，对吗？）

但是，不允许将任何内容放入协变结构中

myNumst.add(45L); //compiler error

这是不允许的，因为Java无法保证泛型结构中对象的实际类型。它可以是任何扩展数字的东西，但编译器不能确定。所以你可以读，但不能写

逆变

相反，你可以做相反的事情。你可以把东西放到一个通用结构中，但你不能从中读出

List<Object> myObjs = new List<Object>();
myObjs.add("Luke");
myObjs.add("Obi-wan");

List<? super Number> myNums = myObjs;
myNums.add(10);
myNums.add(3.14);

在这种情况下，对象的实际性质是一个对象列表，通过逆变，您可以将数字放入其中，基本上是因为所有数字都将对象作为它们的共同祖先。因此，所有数字都是对象，因此这是有效的

然而，假设你能得到一个数字，你就不能安全地从这个反变结构中读取任何东西

Number myNum = myNums.get(0); //compiler-error

如您所见，如果编译器允许您编写这一行，您将在运行时得到ClassCastException

Get/Put原则

因此，当您只想从结构中提取泛型值时，请使用协方差；当您只想将泛型值放入结构中时，请使用逆变；当您想同时执行这两种操作时，请使用确切的泛型类型

我有一个最好的例子，它将任何类型的数字从一个列表复制到另一个列表中。它只从源中获取项，并且只将项放入目标中

public static void copy(List<? extends Number> source, List<? super Number> target) {
    for(Number number : source) {
        target.add(number);
    }
}

由于协方差和逆方差的力量，这适用于这样的情况：

List<Integer> myInts = asList(1,2,3,4);
List<Double> myDoubles = asList(3.14, 6.28);
List<Object> myObjs = new ArrayList<Object>();

copy(myInts, myObjs);
copy(myDoubles, myObjs);

Answer 6

第一个（<? super E>）说它是“E的祖先（超类）的某种类型”；第二个（<? extends E>）说它是“E的一个子类的某种类型”。（在这两种情况下，E本身是可以的。）

因此，构造函数使用? extends E形式，因此它保证当它从集合中获取值时，它们都将是E或某个子类（即，它是兼容的）。drainTo方法试图将值放入集合中，因此集合必须具有E或超类的元素类型

例如，假设您有这样一个类层次结构：

Parent extends Object
Child extends Parent

和LinkedBlockingQueue<Parent>。您可以在List<Child>中构造这个传递，它将安全地复制所有元素，因为每个Child都是父元素。无法传入List<Object>，因为某些元素可能与Parent不兼容

同样，您可以将该队列排入List<Object>，因为每个Parent都是一个Object。。。但是您不能将其排入List<Child>，因为List<Child>希望其所有元素都与Child兼容