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

comme je l'explique dans ma réponse à une autre question, PECS est un dispositif mnémotechnique créé par Josh Bloch pour aider à se souvenir P roducer extends , c onsumer super .

Cela signifie que lorsqu'un type paramétré passé à une méthode produire cas de T (ils seront récupérées à partir d'une certaine façon), ? extends T doit être utilisé, puisque toute instance d'une sous-classe de T est aussi un T .

quand un type paramétré étant passé à une méthode sera consommer instances de T (ils seront passés à elle pour faire quelque chose), ? super T doit être utilisé parce qu'une instance de T peut légalement être passé à toute méthode qui accepte un certain supertype de T . Un Comparator<Number> pourrait être utilisé sur un Collection<Integer> , exemple. ? extends T ne fonctionnerait pas, parce qu'un Comparator<Integer> ne pourrait pas fonctionner sur un Collection<Number> .

notez qu'en général vous ne devez utiliser ? extends T et ? super T que pour les paramètres d'une méthode. Les méthodes doivent juste utiliser T comme paramètre de type sur un type de retour Générique.

en bref facile à se rappeler PECS

1. utilisez le Joker <? extends T> si vous avez besoin de récupérer l'objet de tapez T d'une collection.
2. utilisez le Joker <? super T> si vous avez besoin de mettre des objets de type T dans collection.
3. si vous avez besoin de satisfaire les deux choses, n'utilisez pas de Joker. Comme simple qu'il soit.

(ajouter une réponse parce que jamais assez d'exemples avec des caractères génériques wildcards)

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

rappelez-vous ceci:

"151900920 du Consommateur" manger cène (super); Producteur s'étend de ses parents usine

assumons cette hiérarchie:

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

clarifions PE-Producer Extends:

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

pourquoi vous ne pouvez pas ajouter des objets qui étendent "Shark" dans cette liste? comme:

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

puisque vous avez une liste qui peut être de type A, B ou C à l'exécution , vous ne pouvez pas y ajouter d'objet de type A, B ou C parce que vous pouvez finir avec une combinaison qui est pas autorisés en java.

dans la pratique, le compilateur peut effectivement voir à l'heure du compilateur que vous ajoutez un B:

sharks.add(new HammerShark());

...mais il n'a aucun moyen de dire si à l'exécution, Votre B sera un sous-type ou supertype du type de liste. À l'exécution, le type de liste peut être n'importe lequel des types A, B, C. Ainsi, vous ne pouvez pas finir par ajouter HammerSkark (super type) dans une liste de DeadHammerShark par exemple.

*Vous allez dire: "OK, mais pourquoi ne puis-je pas ajouter HammerSkark en elle puisque c'est le plus petit type?". Réponse: C'est le plus petit vous savoir. Acheter HammerSkark peut être augmenté par quelqu'un d'autre et vous vous retrouvez dans le même scénario.

clarifions CS-Consumer Super:

dans la même hiérarchie nous pouvons essayer ceci:

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

Ce qui et pourquoi vous peut ajouter à cette liste?

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

vous pouvez ajouter les types d'objets ci-dessus parce que tout ce qui est en dessous de requin(A,B,C) sera toujours des sous-types de tout ce qui est au-dessus de requin (X,Y,Z). Facile à comprendre.

Vous ne peut pas ajouter des types ci-dessus de Requin, parce que au moment de l'exécution le type de l'objet ajouté peut être plus élevé dans la hiérarchie que le type déclaré de la liste(X,Y,Z). Ce n'est pas autorisé.

mais pourquoi ne pouvez-vous pas lire à partir de cette liste? (Je veux dire que vous peut en retirer un élément, mais vous ne pouvez pas l'affecter à autre chose que L'objet o):

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

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

à l'exécution, le type de liste peut être n'importe quel type au-dessus de A: X, Y, Z, ... Le compilateur peut compiler votre instruction d'affectation (ce qui semble correct) mais, à l'exécution le type de s(Animal) peut être inférieur dans la hiérarchie que le type déclaré de la liste (qui pourrait être créature, ou supérieur). Ce n'est pas autorisé.

pour résumer

nous utilisons <? super T> pour ajouter des objets de types égaux ou inférieurs à T dans la liste. nous ne pouvons pas lire de il.

nous utilisons <? extends T> pour lire les objets des types égaux ou inférieurs à T de la liste. nous ne pouvons pas y ajouter d'élément.

les caractères génériques peuvent être utilisés de trois façons:"

              - Upper bound Wildcard  ( ? extends Type ).

              - Lower bound Wildcard  ( ? super Type ) .

              - Unbounded Wildcard    ( ? ) .

pour les besoins de cette discussion, il est utile de penser aux variables comme fournissant l'une des deux fonctions:

                      - In Variable

                              An "in" variable serves up data to the code. 
                              Imagine a copy method with two arguments: 
                                      copy(src, dest)
                              The src argument provides the data to be copied, so it is the "in" parameter.
                      - Out Variable

                              An "out" variable holds data for use elsewhere. In the copy example, 
                                      copy(src, dest)
                              the dest argument accepts data, so it is the "out" parameter.

              An "in" variable is defined with an upper bounded wildcard, using the extends keyword.
              An "out" variable is defined with a lower bounded wildcard, using the super keyword.
              In the case where the "in" variable can be accessed using methods defined in the Object class, use an unbounded wildcard.
              In the case where the code needs to access the variable as both an "in" and an "out" variable, do not use a wildcard.

                      class NaturalNumber 
                      {

                              private int i;

                              public NaturalNumber(int i)
                              { 
                                      this.i = i;
                              }
                      }

                          class EvenNumber extends NaturalNumber 
                          {

                              public EvenNumber(int i) 
                              { 
                                      super(i);
                              }
                          }

              Consider the following code:

                      List<EvenNumber> le = new ArrayList<>();
                      List<? extends NaturalNumber> ln = le;
                      ln.add(new NaturalNumber(35));  // compile-time error


                      You can add null.
                      You can invoke clear.
                      You can get the iterator and invoke remove.
                      You can capture the wildcard and write elements that you've read from the list.