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

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

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

public LinkedBlockingQueue(Collection<? extends E> c)

对于方法之一：

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

第一个说它是“是E的祖先的某种类型”。第二句话说它是“某种类型，它是E的子类”。（在两种情况下，E本身都可以。）

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

举例来说，假设您具有这样的类层次结构：

Parent extends Object
Child extends Parent

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

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

这样做的原因基于Java如何实现泛型。

数组示例

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

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

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

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

最后一行可以正常编译，但是如果运行此代码，则可能会 ArrayStoreException。因为您尝试将双精度型放入整数数组中（无论通过数字引用进行访问）。

这意味着您可以欺骗编译器，但不能欺骗运行时类型系统。之所以这样，是因为数组是我们所谓的可更新类型。这意味着Java在运行时知道此数组实际上是作为整数数组实例化的，而该数组恰好是通过type的引用来访问的Number[]。

因此，正如您所看到的，一件事是对象的实际类型，另一件事是用于访问它的引用的类型，对吗？

Java泛型的问题

现在，Java泛型类型的问题在于类型信息被编译器丢弃，并且在运行时不可用。此过程称为类型擦除。有充分的理由在Java中实现这样的泛型，但这是一个很长的故事，除其他外，它必须与已有代码的二进制兼容性（请参阅如何获得我们的泛型））。

但是这里的重点是，由于在运行时没有类型信息，因此无法确保我们不会造成堆污染。

例如，

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); 

因为您可以确定实际列表中包含的内容，都可以将其向上转换为Number（所有扩展Number的东西都是Number，对吗？）

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

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

这是不允许的，因为Java无法保证泛型结构中对象的实际类型是什么。它可以是扩展Number的任何内容，但是编译器无法确定。这样您可以阅读，但不能书写。

逆差

有了相反性，您可以做相反的事情。您可以将事物放入通用结构中，但不能从中读出。

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。

获取/放置原理

因此，在仅打算将通用值从结构中取出时，请使用协方差；在仅打算将通用值放入结构中时，请使用逆方差；当您打算同时使用两者时，请使用确切的通用类型。

我最好的例子是将以下任何一种数字从一个列表复制到另一个列表中。它仅从源获取项目，并且仅将项目放入目标。

public static void copy(List<? extends Number> source, List<? super Number> target) {
    for(Number number : source) {
        target(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);

<? extends E>定义E为上限：“可以强制转换为E”。

<? super E>定义E为下限：“ E可以强制为此。”

我将尝试回答这个问题。但是要获得一个很好的答案，您应该阅读Joshua Bloch的书《 Effective Java》（第二版）。他描述了助记符PECS，它代表“生产者扩展，超级消费者”。

想法是，如果您的代码使用了对象的通用值，则应使用扩展。但是，如果要为泛型类型生成新值，则应使用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/

<? super E> 手段 any object including E that is parent of E

<? extends E> 手段 any object including E that is child of E .

你可能会想谷歌的条款 逆变（<? 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")

您还应该可以通过以下方法添加一个List<String>（或任何的集合String）addAll：

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

但是，您应该意识到a List<Object>和a List<String>不是等效的，后者也不是前者的子类。需要的是协变类型参数的概念-即<? extends T>即位。

一旦有了这个，就很容易想到还需要逆方差的情况（检查Comparable接口）。

答案之前；请清楚

1. 泛型仅编译时间功能可确保TYPE_SAFETY，它将在RUNTIME期间不可用。
2. 只有带有泛型的引用才可以强制类型安全。如果引用未使用泛型声明，则它将在没有类型安全性的情况下工作。
   

例：

List stringList = new ArrayList<String>();
stringList.add(new Integer(10)); // will be successful.

希望这可以帮助您更清楚地了解通配符。

//NOTE CE - Compilation Error
//      4 - For

class A {}

class B extends A {}

public class Test {

    public static void main(String args[]) {

        A aObj = new A();
        B bObj = new B();

        //We can add object of same type (A) or its subType is legal
        List<A> list_A = new ArrayList<A>();
        list_A.add(aObj);
        list_A.add(bObj); // A aObj = new B(); //Valid
        //list_A.add(new String()); Compilation error (CE);
        //can't add other type   A aObj != new String();


        //We can add object of same type (B) or its subType is legal
        List<B> list_B = new ArrayList<B>();
        //list_B.add(aObj); CE; can't add super type obj to subclass reference
        //Above is wrong similar like B bObj = new A(); which is wrong
        list_B.add(bObj);



        //Wild card (?) must only come for the reference (left side)
        //Both the below are wrong;   
        //List<? super A> wildCard_Wrongly_Used = new ArrayList<? super A>();
        //List<? extends A> wildCard_Wrongly_Used = new ArrayList<? extends A>();


        //Both <? extends A>; and <? super A> reference will accept = new ArrayList<A>
        List<? super A> list_4__A_AND_SuperClass_A = new ArrayList<A>();
                        list_4__A_AND_SuperClass_A = new ArrayList<Object>();
                      //list_4_A_AND_SuperClass_A = new ArrayList<B>(); CE B is SubClass of A
                      //list_4_A_AND_SuperClass_A = new ArrayList<String>(); CE String is not super of A  
        List<? extends A> list_4__A_AND_SubClass_A = new ArrayList<A>();
                          list_4__A_AND_SubClass_A = new ArrayList<B>();
                        //list_4__A_AND_SubClass_A = new ArrayList<Object>(); CE Object is SuperClass of A


        //CE; super reference, only accepts list of A or its super classes.
        //List<? super A> list_4__A_AND_SuperClass_A = new ArrayList<String>(); 

        //CE; extends reference, only accepts list of A or its sub classes.
        //List<? extends A> list_4__A_AND_SubClass_A = new ArrayList<Object>();

        //With super keyword we can use the same reference to add objects
        //Any sub class object can be assigned to super class reference (A)                  
        list_4__A_AND_SuperClass_A.add(aObj);
        list_4__A_AND_SuperClass_A.add(bObj); // A aObj = new B();
        //list_4__A_AND_SuperClass_A.add(new Object()); // A aObj != new Object(); 
        //list_4__A_AND_SuperClass_A.add(new String()); CE can't add other type

        //We can't put anything into "? extends" structure. 
        //list_4__A_AND_SubClass_A.add(aObj); compilation error
        //list_4__A_AND_SubClass_A.add(bObj); compilation error
        //list_4__A_AND_SubClass_A.add("");   compilation error

        //The Reason is below        
        //List<Apple> apples = new ArrayList<Apple>();
        //List<? extends Fruit> fruits = apples;
        //fruits.add(new Strawberry()); THIS IS WORNG :)

        //Use the ? extends wildcard if you need to retrieve object from a data structure.
        //Use the ? super wildcard if you need to put objects in a data structure.
        //If you need to do both things, don't use any wildcard.


        //Another Solution
        //We need a strong reference(without wild card) to add objects 
        list_A = (ArrayList<A>) list_4__A_AND_SubClass_A;
        list_A.add(aObj);
        list_A.add(bObj);

        list_B = (List<B>) list_4__A_AND_SubClass_A;
        //list_B.add(aObj); compilation error
        list_B.add(bObj);

        private Map<Class<? extends Animal>, List<? extends Animal>> animalListMap;

        public void registerAnimal(Class<? extends Animal> animalClass, Animal animalObject) {

            if (animalListMap.containsKey(animalClass)) {
                //Append to the existing List
                 /*    The ? extends Animal is a wildcard bounded by the Animal class. So animalListMap.get(animalObject);
                 could return a List<Donkey>, List<Mouse>, List<Pikachu>, assuming Donkey, Mouse, and Pikachu were all sub classes of Animal. 
                 However, with the wildcard, you are telling the compiler that you don't care what the actual type is as long as it is a sub type of Animal.      
                 */   
                //List<? extends Animal> animalList = animalListMap.get(animalObject);
                //animalList.add(animalObject);  //Compilation Error because of List<? extends Animal>
                List<Animal> animalList = animalListMap.get(animalObject);
                animalList.add(animalObject);      


            } 
    }

    }
}

具有上限的通配符看起来像“？extends Type”，代表所有属于Type子类型的类型的族，包括Type类型。类型称为上限。

具有下限的通配符看起来像“？super Type”，代表所有类型的族，它们是Type的超类型，包括Type类型。类型称为下限。

您有一个Parent类和一个从Parent类继承的Child类.Parent类是从另一个名为GrandParent Class的类继承的，因此继承顺序为GrandParent> Parent> Child。现在，<？扩展Parent>-接受Parent类或Child类<？超级父级>-接受父级类或GrandParent类