< ? superE > 和 < ? 扩展 E > 之间的区别是什么？

小开

最佳答案

第一个(<? 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兼容。

小开

你可以选择 想在谷歌上搜索关键词 违规行为(<? 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)

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

一旦有了这些，就很容易想到还需要 违规行为的场景(请检查 Comparable接口)。

小开

具有上界的通配符看起来像“ ？“扩展类型”，表示包含 Type 的子类型的所有类型家族，类型 Type 包含在内。类型称为上界。

具有下界的通配符看起来像“ ？“ super Type”，表示所有类型的家族，这些类型是 Type 的超类型，类型包括在内。类型称为下界。

小开

<? 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/

小开

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

数组示例

使用数组可以做到这一点(数组是协变的)

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

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

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

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

这意味着您可以欺骗编译器，但不能欺骗运行时类型系统。这是因为数组就是我们所说的 可再生的类型。这意味着在运行时，Java 知道这个数组实际上被实例化为一个整数数组，而这个整数数组恰好通过 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);

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

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

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

如您所见，如果编译器允许您编写这一行，您将在运行时获得 ClassCastException (因为列表中的项0是 Object，而不是 Number)。

获取/放置原则

因此，当您只打算从结构中取出泛型值时使用协方差，当您只打算将泛型值放入结构中时使用逆变，并且当您打算同时使用这两种类型时使用精确的泛型类型。

我有的最好的例子是下面的例子，它将任何类型的数字从一个列表复制到另一个列表中。它只从得到项目源，并且它只在目标投入项目。

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

小开

在回答之前，请清楚

泛型只有编译时功能，以确保 TYPE _ SAFETY，它不会 b 在 RUNTIME 期间可用。
只有使用泛型的引用才会强制类型安全; 如果引用没有使用泛型声明，那么它将在没有类型安全的情况下工作。

例如:

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(animalClass);
animalList.add(animalObject);




}
}


}
}

小开

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

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

小开

您有一个 Parent 类和一个从 Parent 类继承的 Child 类。Parent 类是从另一个名为 GrandParent 类的类继承的，所以继承顺序是 GrandParent > Parent > Child。现在, < ? 扩展 Parent >-它接受 Parent 类或 Child 类 < ? super Parent >-此选项接受 Parent 类或 GrandParent 类

小开

Super : List < ? super T > ‘ super’保证要添加到集合中的对象是 T 类型的。

二、扩展 : 列表 < ? 扩展 T > “扩展”保证从集合中获取的对象 READ 是 T 类型的。

解说 :

从类型安全的角度来看，在理解“ super”和“ tended”之间的区别时，有三件事情需要考虑。

1. 分配任务: 可以分配给泛型引用的集合类型。

2. 添加: 可以将哪些类型添加到所引用的集合中。

3. 读书: 从所引用的集合中可以读取哪些类型

「 < ? super T >」确保 -

任何类型 T 或其超类的集合都可以被赋值。
类型 T 或其子类的任何对象都可以添加到集合中，因为总是能通过 T 的“是 A”测试。
无法保证从集合中读取的项的类型，除非是“ Object”类型。它可以是 T 类型的任何东西，也可以是包含“ Object”类型的超类。

< ? 延伸 T >’确保

任何类型 T 或其子类的集合都可以被赋值。
不能添加对象，因为我们无法确定引用的类型。 (甚至不能添加类型为‘ T’的对象，因为泛型引用可能被分配给‘ T’的子类型的集合)
从集合中读取的项可以保证为“ T”类型。

考虑类层次结构

类 Base {}

类中间类扩展基{}

类 Third Layer 扩展了 Intermediate {}

public void testGenerics() {


/**
* super: List<? super T> super guarantees object to be ADDED to the collection
* if of type T.
*
* extends: List<? extends T> extend guarantees object READ from collection is
* of type T
*
* Super:-
*
* Assigning : You can assign collection of Type T or its super classes
* including 'Object' class.
*
* Adding: You can add objects of anything of Type T or of its subclasses, as we
* are sure that the object of type T of its subclass always passes Is A test
* for T. You can NOT add any object of superclass of T.
*
* Reading: Always returns Object
*/


/**
* To a Collection of superclass of Intermediate we can assign Collection of
* element of intermediate or its Parent Class including Object class.
*/
List<? super Intermediate> lst = new ArrayList<Base>();
lst = new ArrayList<Intermediate>();
lst = new ArrayList<Object>();


//Can not assign Collection of subtype
lst = new ArrayList<ThirdLayer>(); //Error!


/**
* Elements of subtype of 'Intemediate' can be added as assigned collection is
* guaranteed to be of type 'Intermediate
*/
    

lst.add(new ThirdLayer());


lst.add(new Intermediate());
    

// Can not add any object of superclass of Intermediate
lst.add(new Base()); //Error!


Object o = lst.get(0);
    

// Element fetched from collection can not inferred to be of type anything
// but 'Object'.
Intermediate thr = lst.get(0); //Error!


/**
* extends: List<? extends T> extend guarantees object read from collection is
* of type T
* Assigning : You can assign collection of Type T or its subclasses.
*
* Adding: You cannot add objects of anything of Type T or even objects of its
* subclasses. This is because we can not be sure about the type of collection
* assigned to the reference.
*
* Reading: Always returns object of type 'T'
*/
    

// Can assign collection of class Intermediate or its subclasses.
List<? extends Intermediate> lst1 = new ArrayList<ThirdLayer>();
lst1 = new ArrayList<Base>(); //Error! can not assign super class collection
    

/**
*  No element can be added to the collection as we can not be sure of
*  type of the collection. It can be collection of Class 'Intermediate'
*  or collection of its subtype. For example if a reference happens to be
*  holding a list of class ThirdLayer, it should not be allowed to add an
*  element of type Intermediate. Hence no addition is allowed including type
*  'Intermediate'.
*/
    

lst1.add(new Base()); //Error!
lst1.add(new ThirdLayer()); //Error!
lst1.add(new Intermediate()); //Error!


    

/**
* Return type is always guaranteed to be of type 'Intermediate'. Even if the
* collection hold by the reference is of subtype like 'ThirdLayer', it always
* passes the 'IS A' test for 'Intermediate'
*/
Intermediate elm = lst1.get(0);


/**
* If you want a Collection to accept (aka to be allowed to add) elements of
* type T or its subclasses; simply declare a reference of type T i.e. List<T>
* myList;
*/


List<Intermediate> lst3 = new ArrayList<Intermediate>();
lst3 = new ArrayList<ThirdLayer>(); //Error!
lst3 = new ArrayList<Base>(); //Error!


lst3.add(new Intermediate());
lst3.add(new ThirdLayer());  // Allowed as ThirdLayer passes 'IS A' for Intermediate
lst3.add(new Base()); //Error! No guarantee for superclasses of Intermediate
}