（添加答案，因为使用泛型通配符的示例永远不够）

       // Source 
       List<Integer> intList = Arrays.asList(1,2,3);
       List<Double> doubleList = Arrays.asList(2.78,3.14);
       List<Number> numList = Arrays.asList(1,2,2.78,3.14,5);

       // Destination
       List<Integer> intList2 = new ArrayList<>();
       List<Double> doublesList2 = new ArrayList<>();
       List<Number> numList2 = new ArrayList<>();

        // Works
        copyElements1(intList,intList2);         // from int to int
        copyElements1(doubleList,doublesList2);  // from double to double


     static <T> void copyElements1(Collection<T> src, Collection<T> dest) {
        for(T n : src){
            dest.add(n);
         }
      }


     // Let's try to copy intList to its supertype
     copyElements1(intList,numList2); // error, method signature just says "T"
                                      // and here the compiler is given 
                                      // two types: Integer and Number, 
                                      // so which one shall it be?

     // PECS to the rescue!
     copyElements2(intList,numList2);  // possible



    // copy Integer (? extends T) to its supertype (Number is super of Integer)
    private static <T> void copyElements2(Collection<? extends T> src, 
                                          Collection<? super T> dest) {
        for(T n : src){
            dest.add(n);
        }
    }

让我们假设这个层次结构：

class Creature{}// X
class Animal extends Creature{}// Y
class Fish extends Animal{}// Z
class Shark extends Fish{}// A
class HammerSkark extends Shark{}// B
class DeadHammerShark extends HammerSkark{}// C

让我们澄清PE-Producer扩展：

List<? extends Shark> sharks = new ArrayList<>();

为什么不能在此列表中添加扩展“Shark”的对象？如：

sharks.add(new HammerShark());//will result in compilation error

由于您有一个在运行时可以是a、B或C类型的列表，因此您不能在其中添加任何a、B和C类型的对象，因为您可能会得到一个在java中不允许的组合。实际上，编译器确实可以在编译时看到您添加了一个B:

sharks.add(new HammerShark());

…但它无法确定在运行时，您的B是列表类型的子类型还是超类型。在运行时，列表类型可以是A、B、C中的任何一种类型。因此，例如，您不能在DeadHammerShark列表中添加HammerSkark（超级类型）。

*你会说：“好吧，但既然它是最小的类型，为什么我不能在其中添加HammerSkark？”。答：这是你知道的最小的。但HammerSkark也可以被其他人扩展，你最终也会遇到同样的情况。

让我们来澄清一下CS-超级消费者：

在同一层次结构中，我们可以尝试以下操作：

List<? super Shark> sharks = new ArrayList<>();

您可以向此列表中添加什么以及为什么？

sharks.add(new Shark());
sharks.add(new DeadHammerShark());
sharks.add(new HammerSkark());

您可以添加上述类型的对象，因为shark（A、B、C）以下的任何对象都将始终是shark（X、Y、Z）以上的任何对象的子类型。易于理解。

不能在Shark之上添加类型，因为在运行时，添加的对象的类型在层次结构中可能高于列表的声明类型（X、Y、Z）。这是不允许的。

但为什么你不能从这个列表中阅读呢？（我的意思是可以从中获取元素，但不能将其分配给除Object o以外的任何对象）：

Object o;
o = sharks.get(2);// only assignment that works

Animal s;
s = sharks.get(2);//doen't work

在运行时，列表的类型可以是A:X、Y、Z。。。编译器可以编译赋值语句（这似乎是正确的），但在运行时，s（Animal）的类型在层次结构上可以低于列表的声明类型（可以是Creature，也可以更高）。这是不允许的。

综上所述

我们使用<？super T>将类型等于或低于T的对象添加到列表中。我们无法阅读它我们使用<？扩展T>以从列表中读取类型等于或低于T的对象。我们不能向其中添加元素。

PECS（生产者延伸和消费者超级）

[协方差和反方差]

让我们来看看示例

public class A { }
//B is A
public class B extends A { }
//C is A
public class C extends A { }

泛型允许您以安全的方式动态处理类型

//ListA
List<A> listA = new ArrayList<A>();

//add
listA.add(new A());
listA.add(new B());
listA.add(new C());

//get
A a0 = listA.get(0);
A a1 = listA.get(1);
A a2 = listA.get(2);

//ListB
List<B> listB = new ArrayList<B>();

//add
listB.add(new B());

//get
B b0 = listB.get(0);

问题

由于Java的Collection是一种引用类型，因此我们面临以下问题：

问题#1

//not compiled
//danger of **adding** non-B objects using listA reference
listA = listB;

*Swift的泛型没有这样的问题，因为Collection是Value类型[About]，因此创建了一个新的集合

问题#2

//not compiled
//danger of **getting** non-B objects using listB reference
listB = listA;

解决方案-通用通配符

通配符是引用类型功能，不能直接实例化

解决方案#1<? super A>又称下界，又称反方差，又称消费者保证它由A和所有超类操作，这就是为什么添加

List<? super A> listSuperA;
listSuperA = listA;
listSuperA = new ArrayList<Object>();

//add
listSuperA.add(new A());
listSuperA.add(new B());

//get
Object o0 = listSuperA.get(0);

解决方案#2

<? 扩展A>aka上界aka协方差aka生产者保证它由A和所有子类操作，这就是为什么它是安全的

List<? extends A> listExtendsA;
listExtendsA = listA;
listExtendsA = listB;

//get
A a0 = listExtendsA.get(0);

PECS“规则”仅确保以下内容合法：

消费者：什么？它可以合法地指代T制片人：什么？是的，它可以在法律上被T

列表中的典型配对<？扩展T>生产者，列表<？super T>使用者只是确保编译器可以强制执行标准的“is-A”继承关系规则。如果我们可以合法地这样做，那么说＜T extends？＞、＜？extended T>（或者在Scala中更好，如您所见，它是[-T]，[+T]。不幸的是，我们能做的最好的是<？super T>，<？extended T>。

当我第一次遇到这种情况并在脑海中分解时，机制是有道理的，但代码本身对我来说仍然很困惑——我一直在想“似乎边界不应该像那样颠倒”——尽管我对上面的内容很清楚——这只是为了保证遵守标准参考规则。

帮助我的是将普通作业作为类比。

考虑以下（非生产就绪）玩具代码：

// copies the elements of 'producer' into 'consumer'
static <T> void copy(List<? extends T> producer, List<? super T> consumer) {
   for(T t : producer)
       consumer.add(t);
}

用任务类比来说明这一点，对于消费者来说？通配符（未知类型）是引用-赋值的“左侧”-和<？超级T>确保了什么？T“is-A”？-T可以分配给它，因为？是T的超类型（或最多相同类型）。

对于制片人来说，他们的担忧是一样的，只是颠倒了：制片人的？通配符（未知类型）是指代-赋值的“右手边”-和<？扩展T>确保了什么？是“IS-A”T-它可以分配给T，因为？是T的子类型（或至少相同类型）。

请记住：

消费者吃晚餐（超级）；生产商扩大了其母公司的工厂

在处理集合时，在上限或下限通配符之间进行选择的常见规则是PECS。信用

PECS（生产者延伸和消费者超级）

助记符→ 获取（扩展）和放置（超级）原则。

该原则规定：仅从结构中获取值时，请使用扩展通配符。仅将值放入结构中时，请使用超级通配符。当你得到和得到时，不要使用通配符。

Java示例：

class Super {
        Number testCoVariance() {
            return null;
        }
        void testContraVariance(Number parameter) {
        } 
    }
    
    class Sub extends Super {
        @Override
        Integer testCoVariance() {
            return null;
        } //compiles successfully i.e. return type is don't care(Integer is subtype of Number)
        @Override
        void testContraVariance(Integer parameter) {
        } //doesn't support even though Integer is subtype of Number
    }

Liskov替换原则（LSP）指出，“程序中的对象应该用其子类型的实例替换，而不改变程序的正确性”。

在编程语言的类型系统中，键入规则

协变的，如果它保持类型的排序（≤），则将类型从更具体到更通用排序；相反，如果它颠倒了这个顺序；如果两者都不适用，则为不变或非变。

协方差和反方差

只读数据类型（源）可以是协变的；只写数据类型（汇）可以是相反的。充当源和汇的可变数据类型应该是不变的。

要说明这种一般现象，请考虑数组类型。对于Animal类型，我们可以使用Animal[]类型

协变：猫[]是动物[]；反义词：动物[]是猫[]；不变量：动物[]不是猫[]，猫[]不是动物[]。

Java示例：

Object name= new String("prem"); //works
List<Number> numbers = new ArrayList<Integer>();//gets compile time error

Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;
myNumber[0] = 3.14; //attempt of heap pollution i.e. at runtime gets java.lang.ArrayStoreException: java.lang.Double(we can fool compiler but not run-time)

List<String> list=new ArrayList<>();
list.add("prem");
List<Object> listObject=list; //Type mismatch: cannot convert from List<String> to List<Object> at Compiletime  

更多示例

图像src

有界（即朝向某处）通配符：有三种不同的通配符：

差异/非差异：？或扩展对象-无边界通配符。它代表所有类型的家庭。当你得到和投入时使用。共方差：？扩展T（T子体的统治）-带有上限的通配符。T是继承层次结构中最上层的类。仅从结构中获取值时，请使用扩展通配符。抵销方差：？超级T（T祖先的统治）-带有下限的通配符。T是继承层次结构中最底层的类。当只将值放入结构中时，请使用超级通配符。

注意：通配符？表示零或一次，表示未知类型。通配符可以用作参数的类型，而不能用作泛型方法调用或泛型类实例创建的类型参数。（即，当使用通配符时，引用不在程序的其他地方使用，如我们使用T）

 import java.util.ArrayList;
import java.util.List;

class Shape { void draw() {}}

class Circle extends Shape {void draw() {}}

class Square extends Shape {void draw() {}}

class Rectangle extends Shape {void draw() {}}

public class Test {

    public static void main(String[] args) {
        //? extends Shape i.e. can use any sub type of Shape, here Shape is Upper Bound in inheritance hierarchy
        List<? extends Shape> intList5 = new ArrayList<Shape>();
        List<? extends Shape> intList6 = new ArrayList<Cricle>();
        List<? extends Shape> intList7 = new ArrayList<Rectangle>();
        List<? extends Shape> intList9 = new ArrayList<Object>();//ERROR.


        //? super Shape i.e. can use any super type of Shape, here Shape is Lower Bound in inheritance hierarchy
        List<? super Shape> inList5 = new ArrayList<Shape>();
        List<? super Shape> inList6 = new ArrayList<Object>();
        List<? super Shape> inList7 = new ArrayList<Circle>(); //ERROR.

        //-----------------------------------------------------------
        Circle circle = new Circle();
        Shape shape = circle; // OK. Circle IS-A Shape

        List<Circle> circles = new ArrayList<>();
        List<Shape> shapes = circles; // ERROR. List<Circle> is not subtype of List<Shape> even when Circle IS-A Shape

        List<? extends Circle> circles2 = new ArrayList<>();
        List<? extends Shape> shapes2 = circles2; // OK. List<? extends Circle> is subtype of List<? extends Shape>


        //-----------------------------------------------------------
        Shape shape2 = new Shape();
        Circle circle2= (Circle) shape2; // OK. with type casting

        List<Shape> shapes3 = new ArrayList<>();
        List<Circle> circles3 = shapes3; //ERROR. List<Circle> is not subtype of  List<Shape> even Circle is subetype of Shape

        List<? super Shape> shapes4 = new ArrayList<>();
        List<? super Circle> circles4 = shapes4; //OK.
    }

    
    
    /*
     * Example for an upper bound wildcard (Get values i.e Producer `extends`)
     *
     * */
    public void testCoVariance(List<? extends Shape> list) {
        list.add(new Object());//ERROR
        list.add(new Shape()); //ERROR
        list.add(new Circle()); // ERROR
        list.add(new Square()); // ERROR
        list.add(new Rectangle()); // ERROR
        Shape shape= list.get(0);//OK so list act as produces only
    /*
     * You can't add a Shape,Circle,Square,Rectangle to a List<? extends Shape>
     * You can get an object and know that it will be an Shape
     */
    }
    
    
    /*
     * Example for  a lower bound wildcard (Put values i.e Consumer`super`)
     * */
    public void testContraVariance(List<? super Shape> list) {
        list.add(new Object());//ERROR
        list.add(new Shape());//OK
        list.add(new Circle());//OK
        list.add(new Square());//OK
        list.add(new Rectangle());//OK
        Shape shape= list.get(0); // ERROR. Type mismatch, so list acts only as consumer
        Object object= list.get(0); //OK gets an object, but we don't know what kind of Object it is.
        /*
         * You can add a Shape,Circle,Square,Rectangle to a List<? super Shape>
         * You can't get an Shape(but can get Object) and don't know what kind of Shape it is.
         */
    }
}

泛型和示例

协方差和反方差根据类型确定兼容性。在任何一种情况下，方差都是有向关系。协方差可以翻译为“同一方向不同”或不同，而反方差意味着“相反方向不同”，或相反。协变型和逆变型并不相同，但它们之间存在相关性。这些名称暗示了相关性的方向。

https://stackoverflow.com/a/54576828/1697099https://stackoverflow.com/a/64888058/1697099

协方差：接受子类型（只读，即Producer）相反：接受超类型（仅写，即Consumer）