Unnamed Variables & Patterns in Java 22

Mit der Veröffentlichung 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ägnanter und zugleich lesbarer zu gestalten, insbesondere in Verbindung mit Pattern Matching. In diesem Artikel wollen wir dieses Feature ausführlich vorstellen, erläutern, wie es funktioniert und anhand von Beispielen aufzeigen, wie Entwickler davon profitieren können.

Motivation hinter Unnamed Variables

In vielen Programmiersprachen entsteht beim Pattern Matching häufig der Bedarf, Variablen zu deklarieren, die später nicht explizit genutzt werden. In Java musste man bislang dennoch jede Variable benennen, selbst wenn sie anschließend ignoriert wird. Dies führte häufig zu Code wie:

if (obj instanceof String s) {
    // wir benutzen s hier
} else if (obj instanceof Integer i) {
    // wir benutzen i hier
} else if (obj instanceof Double d) {
    // wir benutzen d hier, aber manchmal nicht
}
Code-Sprache: JavaScript (javascript)

Wenn eine Variable nicht benötigt wird, musste man dennoch einen Namen vergeben, was den Code unnötig aufblähte. Java 22 adressiert dieses Problem mit unnamed variables, also anonymen Variablen, die einfach ignoriert werden können.

Syntax von Unnamed Variables

Unnamed Variables werden durch einen Unterstrich _ 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äumter zu schreiben. Ein einfaches Beispiel:

Object obj = 42;

if (obj instanceof Integer _) {
    System.out.println("Es handelt sich um eine Integer-Zahl!");
}
Code-Sprache: JavaScript (javascript)

In diesem Beispiel wird die Variable, die das Integer repräsentiert, nicht benannt und somit auch nicht verwendet. Der Code bleibt sauber und es entsteht kein unnötiger „Noise“ durch ungenutzte Variablen.

Kombination mit Record Patterns

Java 16 führte Records ein, und Java 21/22 erweitert das Pattern Matching stark, insbesondere durch Record Patterns. Unnamed Variables lassen sich hier ebenfalls einsetzen. Angenommen, wir haben folgendes Record:

record Point(int x, int y) {}
Code-Sprache: CSS (css)

Wenn wir nur den x-Wert benötigen, den y-Wert aber ignorieren möchten, können wir _ verwenden:

Point p = new Point(10, 20);

if (p instanceof Point(int x, _)) {
    System.out.println("X-Wert: " + x);
}
Code-Sprache: JavaScript (javascript)

Hier sehen wir klar, dass nur x von Interesse ist, während y bewusst ignoriert wird. Dies verbessert die Lesbarkeit und signalisiert direkt die Absicht des Entwicklers.

Verwendung in Switch Expressions

Ein weiterer spannender Anwendungsfall ist die Kombination von Unnamed Variables mit Switch Expressions. Java 22 erlaubt, dass Patterns direkt in switch verwendet werden, und nicht benötigte Variablen können elegant _ sein:

Object obj = new Point(5, 15);

String description = switch (obj) {
    case Point(int x, _) -> "Punkt auf der X-Achse bei " + x;
    case String _ -> "Es ist ein String";
    default -> "Unbekannter Typ";
};

System.out.println(description);
Code-Sprache: JavaScript (javascript)

Hier sehen wir, dass wir den Y-Wert des Punktes nicht interessieren, ebenso wenig der Inhalt des Strings – die _-Notation macht das klar und sauber.

Vorteile und Best Practices

Die Einführung von Unnamed Variables bringt mehrere Vorteile mit sich:

1. Sauberer Code: Kein unnötiges Deklarieren von Variablen, die nicht genutzt werden.
2. Absicht klar kommuniziert: Leser erkennen sofort, welche Teile eines Patterns relevant sind.
3. Weniger Compiler-Warnungen: Unbenutzte Variablen führen oft zu Warnungen; _ eliminiert diese.
4. Kombination mit bestehenden Features: Funktioniert nahtlos mit Record Patterns, Switch Expressions und klassischen instanceof-Prüfungen.

Best Practices:

• Verwende _ nur für Variablen, die wirklich nicht genutzt werden.
• Vermeide mehrfaches _ in derselben Pattern-Kette, wenn dies die Lesbarkeit beeinträchtigt.
• Kombiniere Unnamed Variables mit Pattern Matching, um den Code so prägnant wie möglich zu halten.

Ein komplexeres Beispiel

Nehmen wir an, wir modellieren geometrische Formen:

sealed interface Shape permits Circle, Rectangle {}

record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

Shape shape = new Rectangle(10, 5);

String areaDescription = switch (shape) {
    case Circle(double r) -> "Kreis mit Fläche: " + (Math.PI * r * r);
    case Rectangle(double w, double h) -> "Rechteck mit Fläche: " + (w * h);
    default -> "Unbekannte Form";
};

System.out.println(areaDescription);
Code-Sprache: JavaScript (javascript)

Wenn wir bei Rechtecken nur die Breite interessieren, können wir _ nutzen:

case Rectangle(double w, _) -> "Rechteckbreite: " + w;
Code-Sprache: JavaScript (javascript)

Dies reduziert visuelles Rauschen und fokussiert auf die relevanten Daten.

Fazit

Das Feature Unnamed Variables & Patterns in Java 22 ist ein kleines, aber mächtiges Werkzeug, das die Lesbarkeit von Code massiv verbessert. Durch die Möglichkeit, Variablen gezielt zu ignorieren, entfällt unnötiger Code, Warnungen werden reduziert und die Intention des Entwicklers wird klar kommuniziert. In Kombination mit den anderen modernen Pattern-Matching-Features von Java – wie Record Patterns oder Switch Expressions – ergibt sich ein deutlich eleganterer, ausdrucksstarker und wartbarer Code.

Für Entwickler, die regelmäßig mit komplexen Datentypen arbeiten oder Pattern Matching in Switch-Ausdrücken einsetzen, ist dies ein besonders wertvolles Feature. Es demonstriert, wie Java weiterhin den Spagat zwischen starker Typisierung und ausdrucksstarker Syntax meistert.