Pattern Matching for instanceof

Java • 29. November 2025 • Lesezeit: 7 Minuten

Wer mit Java arbeitet, kennt den Operator instanceof wahrscheinlich schon länger. Er wird genutzt, um zu prüfen, ob ein Objekt einer bestimmten Klasse oder einem bestimmten Typ entspricht. Doch seit Java 16 gibt es eine deutliche Verbesserung: Pattern Matching für instanceof. Diese Neuerung sorgt nicht nur für kompakteren Code, sondern macht ihn auch sicherer und besser lesbar - besonders für Einsteiger ist das ein echter Gewinn.

Das alte Problem: viele Casts und viel Schreibarbeit

Vor Java 16 sah eine typische Prüfung mit instanceof so aus:

Object obj = "Hallo Welt";

if (obj instanceof String) {
    String text = (String) obj;
    System.out.println("Die Laenge des Textes ist: " + text.length());
}

Auf den ersten Blick ist das leicht verständlich, aber du siehst sicher das Problem: Wir prüfen zuerst, ob obj ein String ist, und müssen danach denselben Ausdruck noch einmal casten. Dieser Cast ist doppelt gemoppelt - das nervt nicht nur, sondern ist auch fehleranfällig, wenn man viele Bedingungen prüft.

Die moderne Lösung: Pattern Matching

Mit Java 16 wurde das sogenannte Pattern Matching for instanceof eingeführt. Damit kannst du in einem Schritt prüfen und gleichzeitig eine neue Variable des passenden Typs anlegen. Das bedeutet: kein doppelter Cast mehr, kein überflüssiger Code.

Object obj = "Hallo Welt";

if (obj instanceof String text) {
    System.out.println("Die Laenge des Textes ist: " + text.length());
}

Das ist deutlich einfacher! Java übernimmt automatisch das Casting, sobald die instanceof-Prüfung erfolgreich ist. Die Variable text ist nur innerhalb des if-Blocks sichtbar - außerhalb existiert sie nicht mehr.

Ausgabe:

Die Laenge des Textes ist: 11

Ein weiteres Beispiel mit Vererbung

Schauen wir uns ein Beispiel mit einer kleinen Klassenhierarchie an. Das ist ein klassischer Fall, wo Pattern Matching richtig praktisch ist.

class Tier {
    void machtGeraeusch() {
        System.out.println("Ein Tier macht ein Geraeusch.");
    }
}

class Hund extends Tier {
    void machtGeraeusch() {
        System.out.println("Wuff!");
    }

    void bringStoeckchen() {
        System.out.println("Der Hund bringt ein Stoeckchen!");
    }
}

public class Beispiel {
    public static void main(String[] args) {
        Tier t = new Hund();

        if (t instanceof Hund hund) {
            hund.machtGeraeusch();
            hund.bringStoeckchen();
        } else {
            t.machtGeraeusch();
        }
    }
}

Ausgabe:

Wuff!
Der Hund bringt ein Stoeckchen!

Ohne Pattern Matching hättest du zuerst geprüft, ob t ein Hund ist, und dann separat gecastet. Mit dieser neuen Schreibweise wird dein Code kürzer und übersichtlicher.

Wann ist das Pattern gültig?

Die Variable, die durch Pattern Matching entsteht (im Beispiel hund), ist nur dann gültig, wenn der Typ wirklich passt. Das bedeutet: innerhalb des if-Blocks ist sie vom Compiler als sicher erkannt. Außerhalb ist sie nicht sichtbar.

Ein Beispiel:

Object obj = 42;

if (obj instanceof String text) {
    System.out.println("Textlaenge: " + text.length());
}

System.out.println(text); // Compilerfehler!

Hier gibt es einen Fehler, weil text nur innerhalb des if-Blocks existiert. Das ist auch gut so - dadurch entstehen weniger Laufzeitfehler, weil du keine Variablen verwendest, die gar nicht gültig sind.

Pattern Matching in Kombination mit logischen Operatoren

Das Feature funktioniert auch in Kombination mit logischen Bedingungen. Wichtig ist dabei die sogenannte Flow-Sensitivität: Java erkennt, wann eine Variable sicher gecastet werden kann - aber nur, wenn der Compiler das logisch nachvollziehen kann.

Object obj = "Java ist cool";

if (obj instanceof String text && text.length() > 5) {
    System.out.println("Langer Text: " + text);
}

Ausgabe:

Langer Text: Java ist cool

Hier funktioniert es, weil die Prüfung obj instanceof String text zuerst ausgeführt wird. Der zweite Teil text.length() > 5 darf den neuen Variablennamen schon verwenden - das ist also völlig erlaubt.

Aber Vorsicht: Bei einem || (oder) sieht es anders aus, denn dort kann der Compiler nicht garantieren, dass die erste Bedingung zutrifft.

Object obj = "Kurz";

if (obj instanceof String text || text.length() > 5) {
    System.out.println(text); // Compilerfehler!
}

Hier weiß der Compiler nicht, ob text überhaupt existiert, wenn die erste Bedingung fehlschlägt. Daher ist das nicht erlaubt. Einsteiger sollten sich merken: Das Pattern gilt nur dort, wo Java sicher weiß, dass der Typ passt.

Pattern Matching und Negationen

Wenn du das Pattern mit einer Negation kombinierst, musst du aufpassen. Beispielsweise:

Object obj = 100;

if (!(obj instanceof String text)) {
    System.out.println("Kein String!");
}

// text ist hier nicht sichtbar

Die Variable text existiert nicht innerhalb des negierten if-Blocks - schließlich kann sie nur dann erstellt werden, wenn die Bedingung wahr ist.

Warum das Ganze so wichtig ist

Viele Anfänger denken, dass Pattern Matching nur eine kleine Abkürzung ist - tatsächlich steckt aber mehr dahinter. Es führt zu sauberem, sicherem und lesbarem Code. Der Compiler übernimmt das Casting, prüft automatisch die Sichtbarkeit und verhindert, dass du versehentlich Variablen außerhalb gültiger Bereiche nutzt.

Gerade wenn du viele Verzweigungen oder polymorphe Strukturen hast (z. B. in großen JavaEE-Anwendungen), sparst du dir viel redundanten Code. Selbst bei kleineren Beispielen siehst du sofort, wie angenehm die Syntax geworden ist.

Ein abschließendes Beispiel mit mehreren Typen

Zum Schluss ein etwas größeres Beispiel, das zeigt, wie Pattern Matching mit verschiedenen Typen zusammenarbeitet.

public class TypChecker {
    public static void main(String[] args) {
        Object[] werte = {"Java", 42, 3.14, true};

        for (Object o : werte) {
            if (o instanceof String s) {
                System.out.println("String: " + s.toUpperCase());
            } else if (o instanceof Integer i) {
                System.out.println("Ganzzahl: " + (i * 2));
            } else if (o instanceof Double d) {
                System.out.println("Kommazahl: " + (d + 1.0));
            } else {
                System.out.println("Unbekannter Typ: " + o);
            }
        }
    }
}

Ausgabe:

String: JAVA
Ganzzahl: 84
Kommazahl: 4.14
Unbekannter Typ: true

So sparst du dir viele Casts und lästige Typprüfungen. Das Ergebnis ist klar strukturiert und leicht verständlich - ideal für alle, die Java gerade lernen oder lesbareren Code schreiben wollen.

Fazit

Das Pattern Matching for instanceof ist eine der elegantesten Verbesserungen der letzten Java-Versionen. Es ist nicht spektakulär auf den ersten Blick, aber es verbessert fast jeden Code, der mit Vererbung, Interfaces oder generischen Objekten arbeitet. Besonders für Einsteiger ist es eine großartige Möglichkeit, den Code kürzer und sicherer zu schreiben, ohne sich über unnötige Casts den Kopf zu zerbrechen.

Wenn du also das nächste Mal prüfen willst, ob ein Objekt ein bestimmter Typ ist - nutze gleich das neue Pattern Matching. Dein zukünftiges Ich wird es dir danken!