{"id":429,"date":"2024-06-05T22:09:56","date_gmt":"2024-06-05T21:09:56","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=429"},"modified":"2024-06-26T22:11:39","modified_gmt":"2024-06-26T21:11:39","slug":"einfuehrung-in-die-java-generics","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=429","title":{"rendered":"Einf\u00fchrung in die Java Generics"},"content":{"rendered":"\n

Java Generics, eingef\u00fchrt in JDK 5.0, sind ein m\u00e4chtiges Werkzeug zur Erh\u00f6hung der Typensicherheit und Lesbarkeit von Code. Generics erm\u00f6glichen es, Klassen, Schnittstellen und Methoden zu erstellen, die mit beliebigen Typen arbeiten k\u00f6nnen, ohne dass dabei auf Typpr\u00fcfung zur Laufzeit (type casting) zur\u00fcckgegriffen werden muss. Dieser Artikel gibt eine umfassende Einf\u00fchrung in die Grundlagen von Java Generics, einschlie\u00dflich ihrer Syntax, Verwendung und der h\u00e4ufigsten Anwendungsf\u00e4lle.<\/p>\n\n\n\n

Die Motivation hinter Generics<\/h3>\n\n\n\n

Vor der Einf\u00fchrung von Generics war die Typensicherheit in Java durch Typpr\u00fcfung zur Laufzeit gew\u00e4hrleistet, was zu un\u00fcbersichtlichem und fehleranf\u00e4lligem Code f\u00fchren konnte. Ein typisches Beispiel war die Verwendung von Collections<\/code>, bei denen die enthaltenen Elemente als Object<\/code> behandelt wurden. Dies erforderte Typumwandlungen (casts), die zur Laufzeit fehlschlagen konnten.<\/p>\n\n\n

List<\/span> list<\/span> = new<\/span> ArrayList();\nlist<\/span>.add(\"Hallo\"<\/span>);\nString s = (String) list<\/span>.get(0<\/span>); \/\/ Typumwandlung notwendig<\/span><\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Dieses Muster ist fehleranf\u00e4llig, da eine falsche Typumwandlung zu ClassCastException<\/code> f\u00fchren kann. Generics wurden eingef\u00fchrt, um diese Probleme zu l\u00f6sen und den Code sicherer und lesbarer zu machen.<\/p>\n\n\n\n
Grundlegende Syntax von Generics<\/h3>\n\n\n\n
Generics erm\u00f6glichen es, Klassen, Schnittstellen und Methoden zu parametrisieren. Ein einfaches Beispiel ist die Verwendung von Generics in der List<\/code>-Schnittstelle:<\/p>\n\n\n
List<\/span><String> list<\/span> = new<\/span> ArrayList<>();\nlist<\/span>.add(\"Hallo\"<\/span>);\nString s = list<\/span>.get(0<\/span>); \/\/ Keine Typumwandlung notwendig<\/span><\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Fall ist List<String><\/code> eine generische Listenschnittstelle, die nur String<\/code>-Objekte akzeptiert. Dies erh\u00f6ht die Typensicherheit, da zur Kompilierzeit \u00fcberpr\u00fcft wird, dass nur String<\/code>-Objekte hinzugef\u00fcgt werden.<\/p>\n\n\n\n
Verwendung von Generics in Klassen und Methoden<\/h3>\n\n\n\n
Generische Klassen und Methoden sind der Kern der Generics in Java. Hier ist ein Beispiel f\u00fcr eine generische Klasse:<\/p>\n\n\n
public<\/span> class<\/span> Box<\/span><T<\/span>> <\/span>{\n    private<\/span> T content;\n\n    public<\/span> void setContent(T content) {\n        this.content = content;\n    }\n\n    public<\/span> T getContent() {\n        return<\/span> content;\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel ist Box<\/code> eine generische Klasse mit einem Typparameter T<\/code>. Dieser Typparameter kann zur Kompilierzeit durch einen beliebigen Typ ersetzt werden.<\/p>\n\n\n
Box<String<\/span>> stringBox = new<\/span> Box<>();\nstringBox.setContent(\"Hello\"<\/span>);\nString<\/span> content = stringBox.getContent();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Generische Methoden<\/h3>\n\n\n\n
Neben generischen Klassen k\u00f6nnen auch Methoden generisch sein. Eine generische Methode wird durch Hinzuf\u00fcgen eines Typparameters vor dem R\u00fcckgabewert deklariert:<\/p>\n\n\n
public<\/span> class<\/span> Utils<\/span> <\/span>{\n    public<\/span> static<\/span> <T> void printArray(T[] array<\/span>) {\n        for<\/span> (T element : array<\/span>) {\n            System.out.println(element);\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier ist printArray<\/code> eine generische Methode, die ein Array eines beliebigen Typs akzeptiert und dessen Elemente ausgibt.<\/p>\n\n\n\n
Einschr\u00e4nkungen und Beschr\u00e4nkungen von Generics<\/h3>\n\n\n\n
Generics bieten viele Vorteile, aber sie haben auch einige Einschr\u00e4nkungen. Eine der wichtigsten ist die Typl\u00f6schung (type erasure). W\u00e4hrend der Kompilierung werden alle generischen Typen entfernt und durch ihre Bound-Typen (oder Object<\/code> wenn keine Bounds definiert sind) ersetzt. Dies bedeutet, dass Generics zur Laufzeit nicht mehr verf\u00fcgbar sind und daher keine Instanzen von generischen Typen erstellt werden k\u00f6nnen:<\/p>\n\n\n
public<\/span> class<\/span> GenericClass<\/span><T<\/span>> <\/span>{\n    \/\/ Kompiliert nicht<\/span>\n    \/\/ T instance = new T();<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Auch ist es nicht m\u00f6glich, Arrays von parametrisierten Typen zu erstellen:<\/p>\n\n\n
List<String<\/span>>[] arrayOfLists = new<\/span> List<String<\/span>>[10<\/span>]; \/\/ Kompiliert nicht<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Wildcards und bounded Type Parameters<\/h3>\n\n\n\n
Java Generics bieten Wildcards (?<\/code>) und begrenzte Typparameter (bounded type parameters), um flexibler mit Typen umgehen zu k\u00f6nnen.<\/p>\n\n\n\n
Ungebundene Wildcards<\/h4>\n\n\n\n
Eine ungebundene Wildcard (?<\/code>) kann jeden beliebigen Typ repr\u00e4sentieren:<\/p>\n\n\n
List<\/span><?<\/span>> list<\/span> = new<\/span> ArrayList<String>();\nlist<\/span> = new<\/span> ArrayList<Integer>();<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Gebundene Wildcards<\/h4>\n\n\n\n
Gebundene Wildcards erm\u00f6glichen es, den Bereich der akzeptierten Typen einzuschr\u00e4nken:<\/p>\n\n\n
public<\/span> void process(List<\/span><?<\/span> extends Number> list<\/span>) {\n    \/\/ Verarbeitet Listen von Number oder deren Unterklassen<\/span>\n}\n\nList<\/span><Integer> intList = new<\/span> ArrayList<>();\nprocess(intList); \/\/ Funktioniert<\/span><\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel akzeptiert process<\/code> nur Listen von Number<\/code> oder deren Unterklassen (Integer<\/code>, Double<\/code> usw.).<\/p>\n\n\n\n
Typinferenz<\/h3>\n\n\n\n
Java unterst\u00fctzt Typinferenz, um die Typen in generischen Methoden und Konstruktoren automatisch zu ermitteln. Dies reduziert die Notwendigkeit, explizite Typen anzugeben:<\/p>\n\n\n
Box<Integer<\/span>><\/span> box = new Box<><\/span>();\nbox.setContent(123);\n\nBox<Integer<\/span>><\/span> inferredBox = Box.of(123); \/\/ Annahme: Box hat eine statische Methode of<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Praxisbeispiele<\/h3>\n\n\n\n
Generics sind weit verbreitet in der Java-Standardbibliothek. Einige h\u00e4ufige Anwendungsf\u00e4lle sind:<\/p>\n\n\n\n
    \n
  • Collections API<\/strong>: List<E><\/code>, Map<K, V><\/code>, Set<E><\/code><\/li>\n\n\n\n
  • Java Streams API<\/strong>: Stream<T><\/code><\/li>\n\n\n\n
  • Future und CompletableFuture<\/strong>: Future<V><\/code>, CompletableFuture<T><\/code><\/li>\n<\/ul>\n\n\n\n
    Hier ist ein erweitertes Beispiel zur Verwendung von Generics in einer benutzerdefinierten Datenstruktur:<\/p>\n\n\n
    public class<\/span> Pair<\/span><K<\/span>, V<\/span>> <\/span>{\n    private K key;\n    private V value;\n\n    public Pair(K key, V value) {\n        this<\/span>.key = key;\n        this<\/span>.value = value;\n    }\n\n    public K getKey() {\n        return<\/span> key;\n    }\n\n    public V getValue() {\n        return<\/span> value;\n    }\n\n    public void<\/span> setKey(K key) {\n        this<\/span>.key = key;\n    }\n\n    public void<\/span> setValue(V value) {\n        this<\/span>.value = value;\n    }\n}\n\nPair<String<\/span>, Integer> pair = new<\/span> Pair<>(\"One\"<\/span>, 1<\/span>);\nString<\/span> key = pair.getKey();\nInteger value = pair.getValue();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Schlussfolgerung<\/h3>\n\n\n\n
    Java Generics sind ein essenzielles Feature, das die Typensicherheit und Lesbarkeit des Codes erheblich verbessert. Durch die Einf\u00fchrung von Typparametern, Wildcards und bounded Type Parameters bieten Generics eine hohe Flexibilit\u00e4t und Wiederverwendbarkeit von Code. Trotz einiger Einschr\u00e4nkungen, wie der Typl\u00f6schung, sind Generics ein m\u00e4chtiges Werkzeug, das in vielen Bereichen der Java-Programmierung unverzichtbar geworden ist. Durch das Verst\u00e4ndnis und die richtige Anwendung von Generics k\u00f6nnen Entwickler robustere und sicherere Java-Anwendungen schreiben.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Java Generics, eingef\u00fchrt in JDK 5.0, sind ein m\u00e4chtiges Werkzeug zur Erh\u00f6hung der Typensicherheit und Lesbarkeit von Code. Generics erm\u00f6glichen es, Klassen, Schnittstellen und Methoden zu erstellen, die mit beliebigen Typen arbeiten k\u00f6nnen, ohne dass dabei auf Typpr\u00fcfung zur Laufzeit (type casting) zur\u00fcckgegriffen werden muss. Dieser Artikel gibt eine umfassende Einf\u00fchrung in die Grundlagen von […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-429","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/429","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=429"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/429\/revisions"}],"predecessor-version":[{"id":430,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/429\/revisions\/430"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=429"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=429"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=429"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}