什么是<?super e>和<?扩展E?

第一种说法是“某种类型,它是e的祖先”;第二种说法是“某种类型,它是e的一个子类”。(在这两种情况下,E本身是可以的。)

因此,构造函数使用 ? extends E 这样它就保证了 取 集合中的值,它们都是e或某些子类(即,它是兼容的)。这个 drainTo 方法正在尝试放置值 进入之内 集合,因此集合的元素类型必须为 E 或超类 .

例如,假设您有这样的类层次结构:

Parent extends Object
Child extends Parent

和A LinkedBlockingQueue<Parent> .你可以在一个 List<Child> 它将安全地复制所有元素,因为 Child 是父母。你不能通过 List<Object> 因为有些元素可能与 Parent .

同样,您也可以将队列排入 列表对象 因为每一个 起源 是一个 Object …但你不能把它排成 列出<子项> 因为 列出<子项> 希望其所有元素都与 孩子 .

这是基于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中实现类似这样的泛型是有充分理由的,但这是一个很长的故事,它与二进制代码兼容性与预先存在的代码有关。

但这里重要的一点是,由于在运行时没有类型信息,因此无法确保我们没有提交堆污染。

例如,

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。

获取/输出原则

因此,当您只打算将泛型值从结构中取出时,请使用协方差;当您只打算将泛型值放入结构中时,请使用协方差;当您打算同时执行这两项操作时,请使用完全相同的泛型类型。

我有一个最好的例子,它可以将任何类型的数字从一个列表复制到另一个列表中。只有它 得到 源中的项,仅此 放 目标中的项。

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的书有效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 .

你可能 want to google for the terms 逆变 ( <? super E> ) 协方差 ( <? extends E> )我发现理解泛型最有用的是理解 Collection.addAll :

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

就像你想增加一个 String 到A List<Object> :

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

您还应该能够添加 List<String> (或 弦 S)通过 addAll 方法:

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

但是你应该意识到 列表对象 和A 列表<字符串> 不是等价的,后者也不是前者的子类。需要的是 协变的 类型参数-即 <? extends T> 比特。

一旦你有了这个,很容易想到你想要的场景 逆变 也检查 Comparable 接口。

在回答之前,请明确

1. 泛型只编译时特性以确保类型_的安全性,它在运行时不可用。
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);      


            } 
    }

    }
}

带有上界的通配符看起来像“?扩展类型“并表示作为类型子类型的所有类型的族,类型类型类型包含在内。类型被称为上界。

带有下限的通配符看起来像“?“超级类型”,代表所有类型的族,这些类型是类型的超级类型,包括类型类型类型。类型被称为下限。

您有一个父类和一个从父类继承的子类。父类是从另一个名为祖父母类的类继承的。因此继承顺序是祖父母>父>子级。 现在, &?扩展父类-这接受父类或子类 &?超级父级>-这接受父级或祖父母级