{"id":642,"date":"2026-02-07T00:54:18","date_gmt":"2026-02-06T23:54:18","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=642"},"modified":"2026-02-16T01:02:03","modified_gmt":"2026-02-16T00:02:03","slug":"unnamed-variables-patterns-in-java-22","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=642","title":{"rendered":"Unnamed Variables & Patterns in Java 22"},"content":{"rendered":"\n

Mit der Ver\u00f6ffentlichung von Java 22<\/strong> hat die Java-Plattform erneut einen bedeutenden Schritt in Richtung moderner Sprachfeatures gemacht. Ein besonders spannendes Feature sind die sogenannten Unnamed Variables & Patterns<\/strong>. Dieses Feature zielt darauf ab, den Code klarer, pr\u00e4gnanter und zugleich lesbarer zu gestalten, insbesondere in Verbindung mit Pattern Matching<\/strong>. In diesem Artikel wollen wir dieses Feature ausf\u00fchrlich vorstellen, erl\u00e4utern, wie es funktioniert und anhand von Beispielen aufzeigen, wie Entwickler davon profitieren k\u00f6nnen.<\/p>\n\n\n\n

Motivation hinter Unnamed Variables<\/h2>\n\n\n\n

In vielen Programmiersprachen entsteht beim Pattern Matching h\u00e4ufig der Bedarf, Variablen zu deklarieren, die sp\u00e4ter nicht explizit genutzt werden. In Java musste man bislang dennoch jede Variable benennen, selbst wenn sie anschlie\u00dfend ignoriert wird. Dies f\u00fchrte h\u00e4ufig zu Code wie:<\/p>\n\n\n

if<\/span> (obj instanceof<\/span> String<\/span> s) {\n    \/\/ wir benutzen s hier<\/span>\n} else<\/span> if<\/span> (obj instanceof<\/span> Integer i) {\n    \/\/ wir benutzen i hier<\/span>\n} else<\/span> if<\/span> (obj instanceof<\/span> Double d) {\n    \/\/ wir benutzen d hier, aber manchmal nicht<\/span>\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Wenn eine Variable nicht ben\u00f6tigt wird, musste man dennoch einen Namen vergeben, was den Code unn\u00f6tig aufbl\u00e4hte. Java 22 adressiert dieses Problem mit unnamed variables<\/strong>, also anonymen Variablen, die einfach ignoriert werden k\u00f6nnen.<\/p>\n\n\n\n
Syntax von Unnamed Variables<\/h2>\n\n\n\n
Unnamed Variables werden durch einen Unterstrich _<\/code> dargestellt. Der Unterstrich signalisiert dem Compiler, dass die Variable zwar Teil des Patterns ist, aber nicht verwendet wird. Das erlaubt es, Patterns klarer und aufger\u00e4umter zu schreiben. Ein einfaches Beispiel:<\/p>\n\n\n
Object<\/span> obj = 42<\/span>;\n\nif<\/span> (obj instanceof<\/span> Integer _) {\n    System.out.println(\"Es handelt sich um eine Integer-Zahl!\"<\/span>);\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird die Variable, die das Integer<\/code> repr\u00e4sentiert, nicht benannt und somit auch nicht verwendet. Der Code bleibt sauber und es entsteht kein unn\u00f6tiger \u201eNoise\u201c durch ungenutzte Variablen.<\/p>\n\n\n\n
Kombination mit Record Patterns<\/h2>\n\n\n\n
Java 16 f\u00fchrte Records<\/strong> ein, und Java 21\/22 erweitert das Pattern Matching stark, insbesondere durch Record Patterns<\/strong>. Unnamed Variables lassen sich hier ebenfalls einsetzen. Angenommen, wir haben folgendes Record:<\/p>\n\n\n
record<\/span> Point<\/span>(int<\/span> x<\/span>, int<\/span> y<\/span>) {}\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Wenn wir nur den x<\/code>-Wert ben\u00f6tigen, den y<\/code>-Wert aber ignorieren m\u00f6chten, k\u00f6nnen wir _<\/code> verwenden:<\/p>\n\n\n
Point p = new<\/span> Point(10<\/span>, 20<\/span>);\n\nif<\/span> (p instanceof<\/span> Point(int x, _)) {\n    System.out.println(\"X-Wert: \"<\/span> + x);\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier sehen wir klar, dass nur x<\/code> von Interesse ist, w\u00e4hrend y<\/code> bewusst ignoriert wird. Dies verbessert die Lesbarkeit und signalisiert direkt die Absicht des Entwicklers.<\/p>\n\n\n\n
Verwendung in Switch Expressions<\/h2>\n\n\n\n
Ein weiterer spannender Anwendungsfall ist die Kombination von Unnamed Variables<\/strong> mit Switch Expressions<\/strong>. Java 22 erlaubt, dass Patterns direkt in switch<\/code> verwendet werden, und nicht ben\u00f6tigte Variablen k\u00f6nnen elegant _<\/code> sein:<\/p>\n\n\n
Object<\/span> obj = new<\/span> Point(5<\/span>, 15<\/span>);\n\nString<\/span> description = switch<\/span> (obj) {\n    case<\/span> Point(int x, _) -> \"Punkt auf der X-Achse bei \"<\/span> + x;\n    case<\/span> String<\/span> _ -> \"Es ist ein String\"<\/span>;\n    default<\/span> -> \"Unbekannter Typ\"<\/span>;\n};\n\nSystem.out.println(description);\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier sehen wir, dass wir den Y-Wert des Punktes nicht interessieren, ebenso wenig der Inhalt des Strings \u2013 die _<\/code>-Notation macht das klar und sauber.<\/p>\n\n\n\n
Vorteile und Best Practices<\/h2>\n\n\n\n
Die Einf\u00fchrung von Unnamed Variables bringt mehrere Vorteile mit sich:<\/p>\n\n\n\n
    \n
  1. Sauberer Code:<\/strong> Kein unn\u00f6tiges Deklarieren von Variablen, die nicht genutzt werden.<\/li>\n\n\n\n
  2. Absicht klar kommuniziert:<\/strong> Leser erkennen sofort, welche Teile eines Patterns relevant sind.<\/li>\n\n\n\n
  3. Weniger Compiler-Warnungen:<\/strong> Unbenutzte Variablen f\u00fchren oft zu Warnungen; _<\/code> eliminiert diese.<\/li>\n\n\n\n
  4. Kombination mit bestehenden Features:<\/strong> Funktioniert nahtlos mit Record Patterns, Switch Expressions und klassischen instanceof-Pr\u00fcfungen.<\/li>\n<\/ol>\n\n\n\n
    Best Practices:<\/strong><\/p>\n\n\n\n
      \n
    • Verwende _<\/code> nur f\u00fcr Variablen, die wirklich nicht genutzt werden.<\/li>\n\n\n\n
    • Vermeide mehrfaches _<\/code> in derselben Pattern-Kette, wenn dies die Lesbarkeit beeintr\u00e4chtigt.<\/li>\n\n\n\n
    • Kombiniere Unnamed Variables mit Pattern Matching, um den Code so pr\u00e4gnant wie m\u00f6glich zu halten.<\/li>\n<\/ul>\n\n\n\n
      Ein komplexeres Beispiel<\/h2>\n\n\n\n
      Nehmen wir an, wir modellieren geometrische Formen:<\/p>\n\n\n
      sealed interface Shape permits Circle, Rectangle {}\n\nrecord Circle(double radius) implements Shape {}\nrecord Rectangle(double width, double height) implements Shape {}\n\nShape shape = new<\/span> Rectangle(10<\/span>, 5<\/span>);\n\nString<\/span> areaDescription = switch<\/span> (shape) {\n    case<\/span> Circle(double r) -> \"Kreis mit Fl\u00e4che: \"<\/span> + (Math<\/span>.PI * r * r);\n    case<\/span> Rectangle(double w, double h) -> \"Rechteck mit Fl\u00e4che: \"<\/span> + (w * h);\n    default<\/span> -> \"Unbekannte Form\"<\/span>;\n};\n\nSystem.out.println(areaDescription);\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Wenn wir bei Rechtecken nur die Breite interessieren, k\u00f6nnen wir _<\/code> nutzen:<\/p>\n\n\n
      case<\/span> Rectangle(double w, _) -> \"Rechteckbreite: \"<\/span> + w;\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Dies reduziert visuelles Rauschen und fokussiert auf die relevanten Daten.<\/p>\n\n\n\n
      Fazit<\/h2>\n\n\n\n
      Das Feature Unnamed Variables & Patterns<\/strong> in Java 22<\/strong> ist ein kleines, aber m\u00e4chtiges Werkzeug, das die Lesbarkeit von Code massiv verbessert. Durch die M\u00f6glichkeit, Variablen gezielt zu ignorieren, entf\u00e4llt unn\u00f6tiger Code, Warnungen werden reduziert und die Intention des Entwicklers wird klar kommuniziert. In Kombination mit den anderen modernen Pattern-Matching-Features von Java \u2013 wie Record Patterns<\/strong> oder Switch Expressions<\/strong> \u2013 ergibt sich ein deutlich eleganterer, ausdrucksstarker und wartbarer Code.<\/p>\n\n\n\n
      F\u00fcr Entwickler, die regelm\u00e4\u00dfig mit komplexen Datentypen arbeiten oder Pattern Matching in Switch-Ausdr\u00fccken einsetzen, ist dies ein besonders wertvolles Feature. Es demonstriert, wie Java weiterhin den Spagat zwischen starker Typisierung<\/strong> und ausdrucksstarker Syntax<\/strong> meistert.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Mit der Ver\u00f6ffentlichung von Java 22 hat die Java-Plattform erneut einen bedeutenden Schritt in Richtung moderner Sprachfeatures gemacht. Ein besonders spannendes Feature sind die sogenannten Unnamed Variables & Patterns. Dieses Feature zielt darauf ab, den Code klarer, pr\u00e4gnanter und zugleich lesbarer zu gestalten, insbesondere in Verbindung mit Pattern Matching. In diesem Artikel wollen wir dieses […]<\/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-642","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\/642","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=642"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/642\/revisions"}],"predecessor-version":[{"id":644,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/642\/revisions\/644"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=642"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=642"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=642"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}