Java Academy · Lektion

Pattern Matching für instanceof

Beim Typentest eine Variable binden

Pattern Matching für instanceof ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Pattern Matching für instanceof

Früher wurde instanceof nach dem Muster „prüfen, dann casten“ verwendet. Pattern Matching verbindet Prüfung und Cast in einem Schritt und bindet eine typisierte Variable, wenn die Prüfung erfolgreich ist.

Der alte Boilerplate-Code

Klassischer Code prüft den Typ und castet anschließend in eine neue Variable. Das ist wiederholungsanfällig und leicht falsch zu schreiben.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

Die neue Form

Ein Typ-Pattern deklariert die Variable inline: if (obj instanceof String s). Wenn die Bedingung wahr ist, enthält s bereits den gecasteten Wert.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            System.out.println(s.length());
        }
    }
}

Die Bindungsvariable

Die Variable s wird als Pattern-Variable bezeichnet. Sie ist überall dort im Gültigkeitsbereich, wo der Compiler beweisen kann, dass das Pattern erfolgreich war. Dadurch wird der Code kürzer und sicherer.

Verwendung in Bedingungen

Innerhalb derselben if-Bedingung können Sie die Pattern-Variable nach && verwenden, weil der Treffer in diesem Zweig garantiert ist.

public class Main {
    public static void main(String[] args) {
        Object obj = "developer";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s);
        }
    }
}

Negation und Flow Scope

Bei einer Negation wird der Gültigkeitsbereich intelligent angepasst. Nach if (!(obj instanceof String s)) return; liegt die Variable s im restlichen Methodenrumpf im Gültigkeitsbereich, weil der Code nur fortgesetzt wird, wenn das Pattern erfolgreich war.

public class Main {
    static int safeLength(Object obj) {
        if (!(obj instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    public static void main(String[] args) {
        System.out.println(safeLength("abc"));
        System.out.println(safeLength(42));
    }
}

equals und Cast ersetzen

Ein typischer Anwendungsfall ist eine übersichtliche equals-Überschreibung: Prüfen Sie den Typ und binden Sie die Variable in einer Zeile, bevor Sie die Felder vergleichen.

public class Main {
    static final class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        public int hashCode() { return x * 31 + y; }
    }

    public static void main(String[] args) {
        System.out.println(new Point(1, 2).equals(new Point(1, 2)));
        System.out.println(new Point(1, 2).equals(new Point(3, 4)));
    }
}

Gemischte Typen behandeln

Verkettete else if-Zweige mit Patterns ermöglichen es, sauber zwischen mehreren möglichen Typen zu unterscheiden.

public class Main {
    static String describe(Object obj) {
        if (obj instanceof Integer i) {
            return "int " + (i * 2);
        } else if (obj instanceof String s) {
            return "string of length " + s.length();
        } else {
            return "unknown";
        }
    }

    public static void main(String[] args) {
        System.out.println(describe(21));
        System.out.println(describe("hello"));
        System.out.println(describe(3.14));
    }
}

null wird nie gematcht

Ein instanceof-Pattern ist für null immer false, genau wie der klassische Operator. Die Pattern-Variable wird daher niemals an null gebunden, wodurch eine häufige Ursache für NPEs entfällt.

public class Main {
    public static void main(String[] args) {
        Object obj = null;
        if (obj instanceof String s) {
            System.out.println("matched: " + s);
        } else {
            System.out.println("null or not a String");
        }
    }
}

Übersichtlicherer, sichererer Code

Pattern Matching entfernt den überflüssigen Cast, begrenzt den Gültigkeitsbereich, sodass Sie die Variable nicht missbrauchen können, und liest sich fast wie englischer Text. In modernem Java ist dies der bevorzugte Stil.

Zusammenführen

Ein kleiner Dispatcher, der verschiedene Eingaben mithilfe von Patterns formatiert.

public class Main {
    static String format(Object o) {
        if (o instanceof Double d) return String.format("%.1f", d);
        if (o instanceof Integer i) return Integer.toString(i);
        if (o instanceof String s && !s.isBlank()) return s.trim();
        return "n/a";
    }

    public static void main(String[] args) {
        System.out.println(format(3.14159));
        System.out.println(format(99));
        System.out.println(format("  spaced  "));
        System.out.println(format(null));
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von instanceof-Patterns.

Zusammenfassung

Sie haben Pattern Matching für instanceof gelernt.

Es verbindet Typprüfung und Cast in einem Ausdruck.
Der Gültigkeitsbereich der Pattern-Variable reicht bis zu der Stelle, an der der Match nachgewiesen ist.
Patterns sind für null false und vermeiden dadurch NPEs.
Es vereinfacht das Überschreiben von equals und die Typverzweigung.

Häufig gestellte Fragen

Ist die Lektion „Pattern Matching für instanceof“ kostenlos?

Ja — der vollständige Text von „Pattern Matching für instanceof“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Pattern Matching für instanceof“?

Beim Typentest eine Variable binden Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Pattern Matching für instanceof“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy