javablog.ch» Generics Gala

Generics Teil 3: Wildcards (und lesender Zugriff darauf)

HeikoMaass — Sun, 10 Sep 2006 17:21:42 +0000

Auch der lesende Zugriff auf Wildcard Referenzen ist eingeschränkt.

In einer ArrayList werden Objekte vom Typ E oder Subtypen von E gespeichert.
Da wir die obere Grenze kennen, können wir bedenkenlos die Supertypen von E (oder E selbst) aus
dieser ArrayList lesen.

Beispiel:

ArrayListnew ArrayList();
stringList.add(new String());
ArrayListextends CharSequence> list = stringList ;
CharSequence cs = list.get(0); // gibt ein Objekt vom Typ CharSequence zurueck.

In einer ArrayList werden Objekte vom Typ E oder die Supertypen von E gespeichert.
Hier kennen wir nur die untere Grenze, und der einzige Cast, der immer funktioniert, ist der
Cast nach Object. Von daher gibt ein lesender Zugriff immer ein Objekt vom Typ Object zurück.

Beispiel:

ArrayList csList = new ArrayList();
csList .add(new String());
ArrayListsuper String> list = csList  ;
Object o = list.get(0); // gibt ein Objekt vom Typ Object zurueck.

Ok, so weit zur Theorie. Aber wo werden diese Wildcards konkret eingesetzt ? Google hilft.

wird in der Klassenbibliothek 25 mal eingesetzt.
Z.B. Collection.addAll(Collection c)

dagegen nur 9 mal.
Z.B. im Konstruktor von TreeSet(Comparator c)

Generics Teil 2: Wildcards (und schreibender Zugriff darauf)

HeikoMaass — Sun, 03 Sep 2006 16:23:57 +0000

Komplexer werden die Generics mit der Verwendung von sogenannten Wildcards. Es gibt 3 Typen von Wildcards:

ArrayList - Die ArrayList kann mit jedem Typ parametisiert worden sein.
ArrayList - Die ArrayList kann mit Typ E oder einer Oberklasse von Typ E parametisiert worden sein. (E markiert dabei die untere Grenze)
ArrayList Die ArrayList kann mit Typ E oder einer Unterklasse von Typ E parametisiert worden sein. (E markiert dabei die obere Grenze)

Jetzt wirds spannend: Der schreibende Zugriff solche Referenzen ist eingeschränkt. Beispielsweise darf ich in eine Wildcard ArrayList nichts hinzufügen. Warum?
Weil nicht bekannt ist, mit welchen Typ diese Liste parametisiert wurde. Wenn ich in die Liste
jeden Typ einfügen könnte, dann könnte ich auch einen Typ einfügen, der nicht zum Parametertyp gecastet werden kann.
Das würde dann eine ClassCastException zur Laufzeit bedeuten. (Und das wäre wiederum unschön).

Beispiel:

ArrayList list = new ArrayList();
list.add(new String()); // semantisch zwar richtig, aber der Compiler kann das nicht zulassen, da sonst auch
list.add(new Object()); // funktionieren wuerde

In eine ArrayList kann ich dagegen Typ E oder eine Unterklasse von Typ E einfügen, da garantiert ist, dass die Liste mit einer Oberklasse von Typ E (oder Typ E selbst) parametisiert wurde. Ein Cast nach E wird also immer funktionieren.

Beispiel:

ArrayListsuper CharSequence> list = new ArrayList();
list.add(new String());   // funktioniert, da String von CharSequence ableitet
// (und so auch nach CharSequence oder hoeher gecastet werden koennte)

In eine ArrayList dürfen überhaupt keine Elemente hinzugefügt werden. Warum?
Weil sonst immer die Gefahr einer ClassCastException besteht.

Beispiel:

ArrayListextends CharSequence> list = new ArrayList();
list.add(new String()); // Compilerfehler. String leitet zwar von CharSequence ab, kann aber nicht nach StringBuffer gecastet werden.

So, genug für heute. Im nächsten Eintrag geht es um dem lesenden Zugriff.

Generics Teil 1: Einführung

HeikoMaass — Sat, 02 Sep 2006 21:01:56 +0000

Vor kurzem wurde ich nach dem Sinn bzw. dem Einsatzzweck von gefragt.
Bevor ich die Frage hier im Blog nochmals beantworte, kurz noch eine ganz kleine Einführung in Generics

Mit dem JDK 5.0 kamen die sogenannten Generics, mit denen Klassen und Methoden zusätzlich
parametisiert werden können (Ähnlich wie die Templates in C++, mit dem Unterschied, dass keine
neuen Klassen pro Parametertyp erstellt werden). Ziel der Generics ist die Lesbarkeit des Codes zu erhöhen und explizite Casts zu reduzieren. Allerdings kann die Verwendung von Generics auch sehr tückisch werden. Aber fangen wir mal einfach an (also ohne Generics):

Der folgende Codeausschnitt wird kompiliert und erzeugt zur Laufzeit eine ClassCastException. Unschön.

ArrayList intList = new ArrayList();
intList.add(new Double(2)); // Semantisch falsch, aber kein Fehler beim Kompilieren.
Integer integer = (Integer) intList.get(0); // Ups, ClassCastException zur Laufzeit

Ungefährlicher ist Codeausschnitt 2, da hier schon der Compiler den Fehler meldet:

ArrayList intList = new ArrayList();
intList.add(new Double(2));                 // Fehler zur Kompilierzeit
Integer integer = (Integer) intList.get(0);

Mit der Verwendung der Generics wird die ArrayListe parametisiert und erlaubt nur das Hinzufügen
von Integer Objekten. Der Compiler unterbindet den fehlerhaften Aufruf und verhindert unliebsame
Überraschungen zur Laufzeit. Schön.

Morgen gibts schon weiter mit Teil 2: Wildcards. Da wirds etwas kniffliger.