Quiz #

Quiz 1 #

Corriger la déclaration de la fonction isPositive pour être plus tolérante.

1
2
3
4
5
6
7
8
9


public boolean isPositive(Box<Number> box) { 
  Number n = box.get();
  return n.doubleValue() > 0.0;
}
...
// pour l'instant, ceci ne compilerait pas:
isPositive( new Box<Integer>(10) ); // ==> true
isPositive( new Box<Double>(1.0) ); // ==> true
isPositive( new Box<BigInteger>("10") ); // ==> true

Cliquez pour consulter la réponse ↕

Réponses

Dans la fonction, box produit un Number. D’après la mnémonique PECS, Produit -> Extends. L’argument est donc covariant.

1
2
3
4


public static boolean isPositive(Box<? extends Number> box) { 
  Number n = box.get();
  return n.doubleValue() > 0.0;
}

Quiz 2 #

Corriger la déclaration de la fonction addTo pour être plus tolérante.

1
2
3
4
5


public static <T> void addTo(List<T> from, List<T> to) { 
  for (T t: from) {
    to.add(t);
  }
}

Cliquez pour consulter la réponse ↕

Réponses

1
2
3
4
5


public static <T> void addTo(List<? extends T> from, List<? super T> to) { 
  for (T t: from) {
    to.add(t);
  }
}

Quiz 3 #

Comment interpréter la méthode forEach d’une collection ?

void forEach(Consumer<? super E> action);

Cliquez pour consulter la réponse ↕

Réponses

Elle est contravariante. Le Consumer consomme bien un élément E. D’après la mnémonique PECS, Consomme -> Super. L’argument est donc contravariant.

Pour le prouver, la méthode pourrait être écrite ainsi:

1
2
3
4
5


void forEach(Consumer<? super E> action) {
  while (hasNext())
    action.accept(next());
  }
}

Quiz 4 #

Comment interpréter la méthode map d’un Optional<T> ?

public <U> Optional<U> map(Function<? super T,? extends U> mapper);

Cliquez pour consulter la réponse ↕

Réponses

L’argument mapper est une référence contravariante sur l’argument T et coraviante sur le type de retour T. Autrement dit, mapper représente une fonction qui consomme (d’après PECS -> super) un T et produit (d’aprèes PECS -> extends) un U.

Dans l’extrait suivant, nous mappons un Stream<String> vers un Stream<Number> en lui passant une fonction qui va de Object -> Integer et non String -> Number. Ceci ne pose aucun problème.

1
2
3
4
5
6
7


Stream<String> cs = Stream.of("22");

// (Stream<String>, String -> Number) -> Stream<Number>
Stream<Number> ns = cs.map( (Object o) -> Integer.valueOf(o.toString()) );
                            \____________________ ____________________/
                                                 V
                                          Object -> Integer

Quiz 5 #

Soit la hiérarchie de types suivante:

       A
     /   \
    B     E
   / \
  C   D
 /
F

Et les déclaration suivante:

1
2
3
4


Box<B> b = new Box<>(new B());
Box<? extends A> ba = b;
Box<? super C> bc = b;
bc.set( ba.get() )

Identifiez quel est ou quels sont les problèmes.

Cliquez pour consulter la réponse ↕

Réponses

Il s’agit de la dernière ligne. ba est une boîte de A, même si elle référence une Box<B>. L’appel à get retourne donc un A.

bc est une boîte de C, il est donc impossible d’y mettre un A. C’est bien l’appel à la méthode set qui pose problème.

Identifiez également les lignes qui posent problème:

1
2
3
4


bc.set( new A() )
bc.set( new D() )
bc.set( new C() )
bc.set( new F() )

Cliquez pour consulter la réponse ↕

Réponses

bc reste une boîte de C. Il est de toute façon possible d’y mettre un C ou n’importe quel type qui dérive de C. Les deux premières lignes ne compilent donc pas.

Et enfin, cette méthode est-elle correcte ?

1
2
3


static void move(Box<? extends C> bc, Box<? super B> bb) {
  bb.set( bc.get() );
}

Cliquez pour consulter la réponse ↕

Réponses

bc est covariant, j’ai bien le droit d’appeler get() qui me retourne un C.

bb est contravariant et il s’agit d’une boîte de B. J’ai donc le droit d’y déposer un C.

Quiz #

Quiz 1 #

Réponses

Quiz 2 #

Réponses

Quiz 3 #

Réponses

Quiz 4 #

Réponses

Quiz 5 #

Covariance

Réponses

Réponses

Réponses