想象一下有这样的层次结构

1. 扩展

通过编写

    List<? extends C2> list;

你是说，list将能够引用类型为ArrayList的对象，其泛型类型是C2的7个子类型之一(包括C2):

C2: new ArrayList<C2>();，(可以存储C2或子类型的对象)或 D1: new ArrayList<D1>();，(可以存储D1或子类型的对象)或 D2: new ArrayList<D2>();，(可以存储D2或子类型的对象)or…

等等。七种不同的情况:

    1) new ArrayList<C2>(): can store C2 D1 D2 E1 E2 E3 E4
    2) new ArrayList<D1>(): can store    D1    E1 E2  
    3) new ArrayList<D2>(): can store       D2       E3 E4
    4) new ArrayList<E1>(): can store          E1             
    5) new ArrayList<E2>(): can store             E2             
    6) new ArrayList<E3>(): can store                E3             
    7) new ArrayList<E4>(): can store                   E4             

对于每种可能的情况，我们都有一组“可存储”类型:这里图形化地表示了7个(红色)集

正如你所看到的，并没有一种安全的类型适用于所有情况:

你不能列举。添加(新的C2 () {});因为可以是list = new ArrayList<D1>(); 你不能列举。添加(新D1 () {});因为可以是list = new ArrayList<D2>();

等等。

2. 超级

通过编写

    List<? super C2> list;

你是说，list将能够引用类型为ArrayList的对象，其泛型类型是C2的7个超类型之一(包括C2):

A1: new ArrayList<A1>();，(可以存储A1或子类型的对象)或 A2: new ArrayList<A2>();，(可以存储A2或子类型的对象)或 A3: new ArrayList<A3>();，(可以存储A3或子类型的对象)or…

等等。七种不同的情况:

    1) new ArrayList<A1>(): can store A1          B1 B2       C1 C2    D1 D2 E1 E2 E3 E4
    2) new ArrayList<A2>(): can store    A2          B2       C1 C2    D1 D2 E1 E2 E3 E4
    3) new ArrayList<A3>(): can store       A3          B3       C2 C3 D1 D2 E1 E2 E3 E4
    4) new ArrayList<A4>(): can store          A4       B3 B4    C2 C3 D1 D2 E1 E2 E3 E4
    5) new ArrayList<B2>(): can store                B2       C1 C2    D1 D2 E1 E2 E3 E4
    6) new ArrayList<B3>(): can store                   B3       C2 C3 D1 D2 E1 E2 E3 E4
    7) new ArrayList<C2>(): can store                            C2    D1 D2 E1 E2 E3 E4

对于每种可能的情况，我们都有一组“可存储”类型:这里图形化地表示了7个(红色)集

正如你所看到的，这里有7种安全类型，在每种情况下都是常见的:C2, D1, D2, E1, E2, E3, E4。

你可以列出。添加(新的C2 () {});因为，不管我们引用的是哪种List, C2都是允许的 你可以列出。添加(新D1 () {});因为，不管我们引用的是哪种List, D1都是允许的

等等。您可能注意到，这些类型对应于从类型C2开始的层次结构。

笔记

如果您希望进行一些测试，这里是完整的层次结构

interface A1{}
interface A2{}
interface A3{}
interface A4{}

interface B1 extends A1{}
interface B2 extends A1,A2{}
interface B3 extends A3,A4{}
interface B4 extends A4{}

interface C1 extends B2{}
interface C2 extends B2,B3{}
interface C3 extends B3{}

interface D1 extends C1,C2{}
interface D2 extends C2{}

interface E1 extends D1{}
interface E2 extends D1{}
interface E3 extends D2{}
interface E4 extends D2{}

这里最令人困惑的是，无论我们指定了什么类型限制，赋值只能以一种方式工作:

baseClassInstance = derivedClassInstance;

您可能认为Integer扩展了Number，并且Integer可以作为<?扩展数字>，但是编译器会告诉你<?extends Number>不能转换为Integer(也就是说，在人类的说法中，任何扩展Number的东西都可以转换为Integer是错误的):

class Holder<T> {
    T v;
    T get() { return v; }
    void set(T n) { v=n; }
}
class A {
    public static void main(String[]args) {
        Holder<? extends Number> he = new Holder();
        Holder<? super Number> hs = new Holder();

        Integer i;
        Number n;
        Object o;

        // Producer Super: always gives an error except
        //       when consumer expects just Object
        i = hs.get(); // <? super Number> cannot be converted to Integer
        n = hs.get(); // <? super Number> cannot be converted to Number
                      // <? super Number> cannot be converted to ... (but
                      //       there is no class between Number and Object)
        o = hs.get();

        // Consumer Super
        hs.set(i);
        hs.set(n);
        hs.set(o); // Object cannot be converted to <? super Number>

        // Producer Extends
        i = he.get(); // <? extends Number> cannot be converted to Integer
        n = he.get();
        o = he.get();

        // Consumer Extends: always gives an error
        he.set(i); // Integer cannot be converted to <? extends Number>
        he.set(n); // Number cannot be converted to <? extends Number>
        he.set(o); // Object cannot be converted to <? extends Number>
    }
}

hs.set(我);是可以的，因为Integer可以转换为Number的任何超类(而不是因为Integer是Number的超类，这不是真的)。

EDIT添加了一条关于消费者扩展和生产者超级的注释——它们没有意义，因为它们相应地指定了什么，而只是对象。建议您记住PECS，因为CEPS从来都没有用。

Super是下界，extends是上界。

根据http://download.oracle.com/javase/tutorial/extra/generics/morefun.html:

解决方法是使用一种形式的 有界通配符我们还没见过 具有下界的通配符。的 语法呢?超级T表示未知 类型是T(或T 本身;记住超类型 关系是自反的)。它是双重的 有界通配符 使用，我们在哪里使用?将T延伸到 表示未知类型 T的子型。

通用通配符针对两个主要需求:

从泛型集合读取 插入到泛型集合中 有三种使用通配符定义集合(变量)的方法。这些都是:

List<?>           listUknown = new ArrayList<A>();
List<? extends A> listUknown = new ArrayList<A>();
List<? super   A> listUknown = new ArrayList<A>();

列表< ?>表示输入未知类型的列表。这可以是一个列表< a >，一个列表<B>，一个列表<字符串>等。

列表< ?extends A>表示A类的实例或A的子类(例如B和C)的对象列表。 列表< ?super A>表示列表被输入到A类或A的超类。

阅读更多信息:http://tutorials.jenkov.com/java-generics/wildcards.html

向上投票的答案涵盖了很多方面的细节。然而，我会尝试用不同的方式来回答这个问题。

我们需要考虑两件事，

1. 对列表变量赋值

列表< ?扩展X> listvar;

在这里，X的任何列表或X的子类列表都可以赋值给listvar。

列表<？ 扩展 数字> 列表变量; listvar = new ArrayList<Number>（）; listvar = new ArrayList<Integer>（）;

---

列表< ?super X> listvar;

在这里，X的任何列表或X的超类列表都可以赋值给listvar。

列表<？ 超级数字>列表变量; listvar = new ArrayList<Number>（）; listvar = new ArrayList<Object>（）;

2. 对列表变量执行读或写操作

`List<? extends X> listvar;`

您可以使用此特性在方法参数中接受一个列表，并对类型X执行任何操作(注意:您只能从列表中读取类型X的对象)。

`List<? super Number> listvar;

您可以使用此特性在方法参数中接受列表，并对Object类型执行任何操作，因为您只能从列表中读取Object类型的对象。是的，这里还有一点，你可以把X类型的对象添加到列表中。

我喜欢来自@Bert F的答案，但这是我大脑看到的方式。

我手里有个X。如果我想把我的X写进一个列表，这个列表需要是一个X的列表，或者是一个我写X时可以向上转换的列表，即X的任何超类…

List<? super   X>

如果我得到一个列表，我想从这个列表中读取一个X，那最好是一个X的列表，或者是一个可以在我读取它们时向上转换为X的列表，即任何扩展X的东西

List<? extends X>