Generische Typen
Ein generischer Typ ist eine generische Klasse oder ein generisches Interface, das über Typen parametrisiert ist.
So kann der Compiler die Typsicherheit für die Klasse oder das Interface erzwingen.
Betrachten wir dieses nicht-generische Container-Interface:
class Container {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
Da es Objekttypen akzeptiert und zurückgibt, funktioniert es mit jedem Nicht-Primitivtyp.
Das hat aber seinen Preis: Ein Teil des Codes ruft vielleicht get auf und erwartet Integer, während ein anderer Teil set aufruft und Strings hinzufügt, was zu einer Laufzeitausnahme führt.
Eine generische Klasse und ein generisches Interface haben die folgenden Formate:
class ClassName<T1, T2, ..., Tn> { ... }
interface InterfaceName<T1, T2, ..., Tn> { ... }
Der Typparameter-Abschnitt, der durch spitze Klammern (<>) begrenzt wird und dem Klassen- oder Interface-Namen folgt, gibt die Typparameter (auch Typvariablen genannt) T1, T2, ..., und Tn an.
Diese können im Rumpf der Klasse oder des Interface verwendet werden, um generische Typsicherheit zu erreichen.
Hier ist die generische Version von Container:
class Container<E> {
private E object;
public void set(E object) { this.object = object; }
public E get() { return object; }
}
Wenn wir sie erstellen, müssen wir nun angeben, welchen Typ sie enthält, und der Compiler erzwingt diese Einschränkung:
// empty <> can infer from context
Container<String> stringContainer = new Container<>();
// compiler knows this is a String, so it is allowed
stringContainer.set("Some string");
// no cast needed, compiler knows it is a String
String result = stringContainer.get();
// this causes a compiler error:
stringContainer.set(42);
Listen
Listen sind in Java die Sammlung für geordnete Sequenzen.
Anders als Arrays kann eine List in ihrer Größe wachsen, um beliebig viele Elemente aufzunehmen.
Eine Standardimplementierung ist die ArrayList, die auf einem Array basiert, dessen Größe angepasst werden kann.
Eine weitere Standardimplementierung ist die Klasse LinkedList, die auf einer doppelt verketteten Liste basiert.
List-Instanzen können leer sein oder beliebig viele Elemente enthalten (einschließlich Duplikate).
List-Instanzen sind ein generisches Interface, das typisiert ist, um anzugeben, welche Art von Objekten sie enthalten können.
Zum Beispiel:
List<String> emptyListOfStrings = List.of();
List<Integer> singleInteger = List.of(1);
List<Boolean> threeBooleans = List.of(true, false, true);
List<Object> listWithMultipleTypes = List.of("hello", 1, true);
List-Instanzen haben verschiedene hilfreiche Methoden, um ein Element hinzuzufügen, zu entfernen, abzurufen und zu prüfen, ob es vorhanden ist:
List<Character> vowels = new ArrayList<>(List.of('a', 'e', 'i', 'o', 'i', 'e', 'a'));
int startingSize = vowels.size(); // 7
vowels.add('u'); // vowels is now ['a', 'e', 'i', 'o', 'i', 'e', 'a', 'u']
char a = vowels.get(0); // 'a'
boolean hadI = vowels.remove('i'); // true and vowels is now ['a', 'e', 'o', 'i', 'e', 'a', 'u']
boolean hasI = vowels.contains('i'); // true (still have one more left)
Lernübung
