<? extends T> und <? super T>

[mrStudent]

Hi Leute, ich wollte euch fragen, wieso es bei <? extends T> der schreibende Zugriff außer (null) nicht geht und bei <? super T> es funktioniert.

static void f ( List<? extends Lebensmittel> l) {

Essen essen = new Essen () ;
Ware ware = new Ware () ;
Lebensmittel lebensmittel = new Lebensmittel () ;

// schreibender Zugriff --> warum klappt das hier nicht ?
l. add ( essen ) ; // Compile - Fehler
l. add ( ware ); // Compile - Fehler
l. add ( lebensmittel ) ; // Compile - Fehler
l. add ( null ); // OK

// lesender Zugriff Lebensmittel lebensmittel2 = l. get (0) ; // OK
Ware ware2 = l . get (0) ; // OK
Object object = l. get (0) ; // OK

 

[httpdigest]

List<? extends T> bedeutet: Es ist eine Liste eines unbekannten/unbestimmten Typs, der von dem bekannten/bestimmten T ableitet.
Konkret weiß man aber nicht, um welchen Typ es sich bei ? tatsächlich handelt. Das einzige, was bekannt ist, ist, dass er auf jeden Fall von T ableitet.
Du kannst weder ein Essen, noch eine Ware noch ein Lebensmittel dieser Liste hinzufügen, weil man eben nicht weiß, ob die Liste tatsächlich Essen, Waren oder Lebensmittel beinhalten würde beim konkreten Aufruf der Methode.
Dass das nicht geht, verhindert auch ein Problem, welches als "Heap Pollution" bezeichnet wird.

Beispiel (mit B extends A; und C extends A):

class A {}
class B extends A {}
class C extends A {}

private void deineMethode(List<? extends A> aListe) {
  aListe.add(new C()); // <- wenn das gehen würde, wäre in der Liste jetzt ein C (tatsächlich käme hier ein Compilererror)
}
public void hauptmethode() {
  List<B> bListe = new ArrayList<B>();
  deineMethode(bListe);
  B einB = bListe.get(0); // <- GEHT NICHT! Es ist ja ein C!
}