Qu'est-ce que PECS (Producer Extends Consumer Super) ?

Question

J'ai découvert le PECS (abréviation de Producteur extends et des consommateurs super ) tout en lisant sur les génériques.

Quelqu'un peut-il m'expliquer comment utiliser le PECS pour résoudre la confusion entre extends et super ?

Answer 1

tl;dr : "PECS" est du point de vue de la collection. Si vous êtes uniquement tirant des éléments d'une collection générique, il s'agit d'un producteur et vous devez utiliser extends ; si vous êtes uniquement Il s'agit d'un consommateur et vous devez utiliser les services de la super . Si vous faites les deux avec la même collection, vous ne devez utiliser ni l'un ni l'autre. extends ou super .

---

Supposons que vous ayez une méthode qui prenne comme paramètre une collection d'objets, mais que vous souhaitiez qu'elle soit plus flexible qu'une simple acceptation d'un fichier Collection<Thing> .

Cas 1 : Vous voulez parcourir la collection et faire des choses avec chaque élément.
Alors la liste est un producteur vous devez donc utiliser un Collection<? extends Thing> .

Le raisonnement est qu'un Collection<? extends Thing> peut contenir n'importe quel sous-type de Thing et ainsi chaque élément se comportera comme un Thing lorsque vous effectuez votre opération. (En fait, vous ne pouvez rien ajouter (sauf null) à un fichier Collection<? extends Thing> parce que vous ne pouvez pas savoir au moment de l'exécution quelle spécifique sous-type de Thing la collection tient).

Cas 2 : Vous voulez ajouter des choses à la collection.
Alors la liste est un consommateur vous devez donc utiliser un Collection<? super Thing> .

Le raisonnement ici est que, contrairement Collection<? extends Thing> , Collection<? super Thing> peut toujours tenir un Thing quel que soit le type réel paramétré. Ici, vous ne vous souciez pas de ce qui se trouve déjà dans la liste, du moment que cela permet d'utiliser un paramètre Thing à ajouter ; c'est ce que ? super Thing garanties.

Answer 2

Les principes qui sous-tendent cette démarche en informatique sont appelés

• Covariance : ? extends MyClass ,
• Contravariance : ? super MyClass et
• Invariance/non-variance : MyClass

L'image ci-dessous devrait expliquer le concept. Photo gracieusement offerte : Andrey Tyukin

Answer 3

PECS (short for Producer extends and Consumer super) peut être expliqué par : Get and Put Principle

Principe Get And Put (tiré de Java Generics and Collections)

Il déclare,

1. utiliser un caractère générique étendu lorsque vous n'obtenez que des valeurs d'une structure
2. utiliser un super joker lorsque vous ne mettez que des valeurs dans une structure
3. et n'utilisez pas de joker lorsque vous utilisez à la fois get et put.

Comprenons-le par l'exemple :

1. For Extends Wildcard(get values i.e Producer extends)

Voici une méthode, qui takes a collection of numbers, converts each to a double, and sums them up

public static double sum(Collection<? extends Number> nums) {
   double s = 0.0;
   for (Number num : nums) 
      s += num.doubleValue();
   return s;
}

Appelons la méthode :

List<Integer>ints = Arrays.asList(1,2,3);
assert sum(ints) == 6.0;
List<Double>doubles = Arrays.asList(2.78,3.14);
assert sum(doubles) == 5.92;
List<Number>nums = Arrays.<Number>asList(1,2,2.78,3.14);
assert sum(nums) == 8.92;

Depuis, sum() method uses extends Si vous utilisez extends, tous les appels suivants sont légaux. Les deux premiers appels ne seraient pas légaux si extends n'était pas utilisé.

EXCEPTION : Vous cannot put anything en un type declared with an extends wildcard—except pour la valeur null qui belongs to every reference type :

List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
ints.add(2);
List<? extends Number> nums = ints;
nums.add(null);  // ok
assert nums.toString().equals("[1, 2, null]");

2. For Super Wildcard(put values i.e Consumer super)

Voici une méthode, that takes a collection of numbers and an integer n, and puts the first n integers, starting from zero, into the collection :

public static void count(Collection<? super Integer> ints, int n) {
    for (int i = 0; i < n; i++) ints.add(i);
}

Appelons la méthode :

List<Integer>ints = new ArrayList<Integer>();
count(ints, 5);
assert ints.toString().equals("[0, 1, 2, 3, 4]");
List<Number>nums = new ArrayList<Number>();
count(nums, 5); nums.add(5.0);
assert nums.toString().equals("[0, 1, 2, 3, 4, 5.0]");
List<Object>objs = new ArrayList<Object>();
count(objs, 5); objs.add("five");
assert objs.toString().equals("[0, 1, 2, 3, 4, five]");

Depuis, count() method uses super tous les appels suivants sont légaux : Les deux derniers appels ne seraient pas légaux si super n'était pas utilisé.

EXCEPTION : vous cannot get anything à partir d'un type declared with a super wildcard—except pour une valeur de type Object qui est un supertype of every reference type :

List<Object> objs = Arrays.<Object>asList(1,"two");
List<? super Integer> ints = objs;
String str = "";
for (Object obj : ints) str += obj.toString();
assert str.equals("1two");

3. When both Get and Put, dont Use wildcard

Quand vous deux put values into and get values out of the same structure vous ne devez pas ne pas utiliser de caractère générique.

public static double sumCount(Collection<Number> nums, int n) {
   count(nums, n);
   return sum(nums);
}

Answer 4

public class Test {

    public class A {}

    public class B extends A {}

    public class C extends B {}

    public void testCoVariance(List<? extends B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b); // does not compile
        myBlist.add(c); // does not compile
        A a = myBlist.get(0); 
    }

    public void testContraVariance(List<? super B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b);
        myBlist.add(c);
        A a = myBlist.get(0); // does not compile
    }
}

Answer 5

Comme je l'explique dans ma réponse Pour répondre à une autre question, PECS est une méthode mnémotechnique créée par Josh Bloch pour aider à se souvenir P roducteur **e**xtends , C onsommateur **s**uper .

Cela signifie que lorsqu'un type paramétré passé à une méthode produire instances de T (ils seront récupérés d'une manière ou d'une autre), ? extends T devrait être utilisé, puisque toute instance d'une sous-classe de T est également un T .

Lorsqu'un type paramétré passé à une méthode sera consommer instances de T (ils lui seront passés pour faire quelque chose), ? super T doit être utilisé car une instance de T peut légalement être passé à n'importe quelle méthode qui accepte un supertype de T . A Comparator<Number> pourrait être utilisé sur un Collection<Integer> par exemple. ? extends T ne fonctionnerait pas, car une Comparator<Integer> ne pouvait pas fonctionner sur un Collection<Number> .

Notez qu'en général, vous ne devriez utiliser que ? extends T et ? super T pour les paramètres d'une méthode. Les méthodes devraient simplement utiliser T comme paramètre de type sur un type de retour générique.