Faulheit professionell: Fertige Datenbehälter. Das Java-Collections-Framework Typsicherheit Generische Klassen

Transkript

1 Faulheit professionell: Fertige Datenbehälter Das Java-Collections-Framework Typsicherheit Generische Klassen

2 Das Java Collections Framework Grundlegende Interfaces

3 Das Interface List

4

5 Das Interface List Interface List extends Collection{ void add(object o); void add(object o, int index); void addall(collection c); void clear(); boolean contains(object o); void remove (Object o); Object remove(int index); int size(); Object[] toarray(); //... und viele weitere Methoden } geeignet für alle listenartigen Datenbehälter

6 java.util.collection: einige Implementierungen

7 Das Java-Collections-Framework: List-Implementierungen Collection AbstractCollection List Abstract List Achtung, Runtime- Exceptions beachten! ArrayList LinkedList Vector

8 Verwendung der Collections: LiFo import java.util.*; // die Collections class LifoVariabel implements LiFo{ private List liste = new ArrayList(); // oder Vector oder LinkedList public void add(object obj) { liste.add(obj,0); // vorn einfügen } public Object remove() { return liste.remove(0); // vorn wegnehmen } }

9 Verwendung der Collections: FiFo import java.util.*; // die Collections class LifoVariabel implements LiFo{ private List liste = new ArrayList(); // oder Vector oder LinkedList public void add(object obj) { liste.add(obj, liste.add(obj); liste.size()-1); // hinten einfügen // hinten (default) einf. } public Object remove() { return liste.remove(0); // vorn wegnehmen } }

10 Iteratoren Implementierungs-unabhängiges Durchlaufen einer Collection Iterator: ein intelligentes Objekt, das durch die Collection navigieren und an beliebiger Stelle Elemente lesen, entfernen oder einfügen kann Merkt sich seine Position für den nächsten Aufruf Mehrere Iteratoren pro Collection sind möglich Wie Affen an einer Palme Zu erzeugen durch die statische Funktion listiterator(), die einen "Affen" vom Typ ListIterator abliefert und an den Anfang der Collection setzt.

11 ListIterator

12 Sortiertes Eintragen mit dem ListIterator liste ist eine abwärts sortierte Liste, in die das Element elem einzutragen ist. Iterator-Funktionen: next() "klettert" eine Stufe weiter und liefert den Eintrag nextindex() liefert den Folgeindex, ohne zu "klettern" public void eintragen(liste liste, Element elem) { ListIterator affe = liste.listiterator(); while ((Element)(affe.next()).greater(elem)) { */ nur weiterlaufen */ } liste.add(elem, affe.nextindex()-1); } Ein zweiter "Affe" könnte parallel etwas anderes an der selben Liste machen..

13 Typsicherheit Antwort moderner Programmiersprachen auf die Fehlinterpretation von Daten 1. Einer Variable dürfen nur Werte ihres Typs zugewiesen werden. 2. Auf einen Wert sind nur die Operationen seines Typs anwendbar. Universelle Transporttypen (Object...) unterlaufen den ersten Aspekt, aber Explizite Typumwandlung wird vom Java-Laufzeitsystem (nachträglich) abgesichert (ClassCastException). 2. Operationssicherheit wird durch die Java-Syntax gewährleistet....trotzdem wären typsichere Datenbehälter besser...

14 Element-Typen Für die Übung haben Sie einen String-Stack implementiert. Nach demselben Muster lässt sich ein Fahrzeug-, int- oder Object- Stack programmieren. Vererbung hilft nicht man muss neu programmieren. Die einzelnen Stacks sind typsicher d.h. der Benutzer kann sich darauf verlassen, Elemente des richtigen Typs zu lesen. Die Standard-Datenbehälter arbeiten mit dem allgemeinen Element-Typ Object. Für beliebige Element-Typen verwendbar. Eintragen ist unmittelbar möglich. Man muss jedes entnommene Element "downcasten", ehe man damit arbeiten kann Typsicherheit ist nicht gegeben (aber die Typverwendung ist abgesichert)

15 Typ-Parametrisierung Statt einen Stack für jeden Elementtyp neu zu programmieren - kann man ihn mit dem Element-Typ parametrisieren: class Stack <Elementtyp> {...} Bei der Instanziierung wählt man den Elementtyp: Stack <String> texte = new Stack <String>(); Stack <Konto> konten = Diamond new Stack <Konto>(); Operator In Java 8 auch: Stack <String> texte = new Stack <>(); Stack <Elementtyp> ist eine generische Klasse: eine Klasse definiert mehrere Typen.

16 Definition generischer Klassen statt Object wird jetzt die Typvariable T verwendet: class StackArray <T> { private T[] stack = new T[size]; private int top = 0; } public void add(t elem) throws OverflowExc { if (top == size) throw new OverflowExc(); stack[top] = elem; top++; } public T remove() throws UndeflowExc { if (top==0) throw new UndeflowExc(); top --; return stack[top]; } Instanziierung: new StackArray<String>(), new StackArray<Person>(), etc.

17 Benutzung generischer Klassen new StackArray<String>(): die Typ-Variable T wird überall durch String ersetzt es können nur String -Elemente eingetragen werden (typsicher) stack.add("hallo"); // ok stack.add(new Person()); // Fehler ausgelesene Elemente haben den Typ String (ohne "downcast") String s = stack.remove(0); // ok

18 Präzisierung am Beispiel ArrayList Ein Blick in die (Java 5-)Dokumentation zeigt, dass der Typ ArrayList als generische Klasse definiert ist: ArrayList<E> ArrayList<E> heißt generische oder typ-parametrisierte Klasse. E heißt formaler Typ-Parameter (oder auch Typ-Variable) und steht für einen beliebigen Typ (hier als Elementtyp verwendet) E kann in der Schnittstelle von ArrayList<E> als Parameter- und Rückgabetyp vorkommen: void add(int index, E element); E remove(int index);

19 Typkompatibilität generischer Klassen generische Klassen sind typsicher: ArrayList<String> liste = new ArrayList<Book>; // Typfehler! ArrayList<Object> liste = new ArrayList<Book>; // Typfehler! warum? der Rückgabetyp von (z.b.) remove ist unterschiedlich, ArrayList<String> hat eine andere Schnittstelle als ArrayList<Book>

20 Rohe Typen ArrayList heißt "roher Typ" von ArrayList<E> ArrayList ist die gemeinsame Klasse aller ihrer parametrisierten Typen (wichtig für statische Variablen). Der Typparameter E ist überall ersetzt durch Object Der rohe Typ ist nicht identisch mit ArrayList<Object> new ArrayList(): Instanziierung des rohen Typs. Die Typ-Variable E wird überall durch Object ersetzt So haben wir den Typ bisher benutzt. Generische Typen sind mit ihrem rohen Typ kompatibel ArrayList list = new ArrayList<String>(); // erlaubt! downcast der gelesenen Werte erforderlich: String s = (String)list.remove(10);

21 Rohe und parametrisierte Typen nicht mischen! ArrayList list = new ArrayList<String>(); // erlaubt! Durch Mischen roher und parametrisierter Typen geht die Typsicherheit verloren. list.add(new Auto()); // erlaubt, weil der rohe Typ // mit Object arbeitet! Rohe Typen mit allergrößter Vorsicht als universelle Transporttypen (für Objekte parametrisierter Typen) benutzen! Keine Operationen darauf anwenden, sondern Objekte vorher einer Variable geeigneten Typs zuweisen! Besser: Finger weg!

22 Parametrisierte Interfaces Interfaces können genauso parametrisiert sein wie Klassen: interface Container <T> { void add(t elem); T remove(); } interface LiFo<T> extends Container<T> {} interface FiFo<T> extends Container<T> {} class StackArray<T> implements LiFo<T> {...} StackArray<String> = new StackArray<String>();

23 Parametrisierung im Java-Collections-Framework Die Klassen des Java-Collection-Framework befinden sich im Paket java.util Alle Klassen, Interfaces und abstrakten Klassen des Java-Collection-Frameworks sind mit dem Elementtyp parametrisiert. Bis Java 1.4 gab es nur die rohen Typen (Elementtyp Object). Das Java-Collection-Interface definiert drei Hierarchien von Datenbehältern: List, Set, Map. Wenn Sie sich mit List gut genug auskennen, erkunden Sie die anderen!

24 Das Interface List

25 Das Interface Collection

26 ..ab jetzt schauen Sie bitte ins Collections Famework, ehe Sie sich selbst einen Datenbehälter zimmern!