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类型的对象放入一个集合。如果您需要同时满足这两个条件，那么不要使用通配符。像就这么简单。

让我们尝试可视化这个概念。

<? super SomeType>是一个“undefined（yet）”类型，但该未定义类型应该是“SomeType”类的超类。

<？扩展SomeType>。它是一个应该扩展“SomeType”类的类型（它应该是“SomeType”类的子类）。

如果我们在Venn图中考虑“类继承”的概念，示例如下：

哺乳动物类扩展了动物类（动物类是哺乳动物类的超类）。

猫/狗类扩展了哺乳动物类（哺乳动物类是猫/狗的超类）。

然后，让我们将上图中的“圆圈”视为具有物理体积的“盒子”。

你不能把更大的盒子放进更小的盒子里。

你只能把一个小盒子放进一个大盒子里。

当你说<？super SomeType>，你想描述一个与“SomeType”框大小相同或更大的“框”。

如果你说<？扩展SomeType>，那么您需要描述一个与SomeType框大小相同或更小的“框”。

那么PECS到底是什么呢？

“生产者”的一个例子是我们只能从中读取的列表。

“消费者”的一个例子是我们只写入的列表。

请记住：

我们从“制片人”那里“阅读”，然后把这些东西带到我们自己的盒子里。我们把自己的盒子“写”成“消费者”。

因此，我们需要从“制片人”那里读到一些东西，并将其放入我们的“盒子”中。这意味着，从生产商那里拿走的任何盒子都不应该比我们的“盒子”大。这就是《制作人延伸》的原因

“延伸”是指一个较小的方框（上图中的较小圆圈）。制片人的盒子应该比我们自己的盒子小，因为我们要从制片人那里拿走这些盒子，然后把它们放进自己的盒子里。我们不能放比我们的箱子更大的东西！

此外，我们需要将自己的“盒子”写入“消费者”。这意味着消费者的箱子不应小于我们自己的箱子。这就是为什么“超级消费者”

“超级”是指一个更大的盒子（上图中的大圆圈）。如果我们想把自己的盒子放进消费者手中，消费者的盒子应该比我们的盒子大！

现在我们很容易理解这个例子：

public class Collections { 
  public static <T> void copy(List<? super T> dest, List<? extends T> src) {
      for (int i = 0; i < src.size(); i++) 
        dest.set(i, src.get(i)); 
  } 
}

在上面的示例中，我们希望从src中读取（获取）一些内容，并将其写入（放入）dest。因此src是一个“Producer”，它的“box”应该比一些类型T小（更具体）。

反之亦然，dest是一个“消费者”，它的“盒子”应该比某些类型的T更大（更一般）。

如果src的“盒子”比dest的大，我们就不能把这些大盒子放进dest的小盒子里。

如果有人读到这篇文章，我希望它能帮助你更好地理解“生产者延伸，消费者超级。”

快乐编码！：）

这是我认为extends与super最清晰、最简单的方式：

扩展用于读取super是用来写作的

我发现“PECS”是一种不明显的方式来思考谁是“生产者”，谁是“消费者”。“PECS”是从数据集合本身的角度定义的——如果对象正在被写入到集合中，则集合“消耗”（它消耗来自调用代码的对象），如果对象正在从集合中读取，则它“产生”（它向某些调用代码产生对象）。这与其他所有事物的命名方式相反。标准JavaAPI是从调用代码的角度命名的，而不是从集合本身命名的。例如，java.util.List的以集合为中心的视图应该有一个名为“receive（）”的方法，而不是“add（）”——毕竟，调用代码添加了元素，但列表本身接收了元素。

我认为从与集合交互的代码的角度来思考事情更直观、更自然、更一致——代码是“从集合中读取”还是“写入”集合？之后，向集合写入的任何代码都将是“生产者”，从集合读取的任何代码将是“消费者”。

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（生产者延伸和消费者超级）

[协方差和反方差]

让我们来看看示例

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