Java Academy · Lektion

Verschachtelte Record Patterns

Tief verschachtelte Daten abgleichen

Verschachtelte Record Patterns ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Verschachtelte Record-Patterns

Record-Patterns können verschachtelt werden: Eine Komponente, die selbst ein Record ist, kann innerhalb des äußeren Patterns destrukturiert werden. So lassen sich tief strukturierte Daten in einem einzigen Ausdruck verarbeiten.

Ein verschachteltes Datenmodell

Betrachten Sie eine Line, die aus zwei Point-Records besteht. Die inneren Records eignen sich ganz natürlich für eine Verschachtelung.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Line line = new Line(new Point(0, 0), new Point(3, 4));
        System.out.println(line);
    }
}

Destrukturierung auf einer Ebene

Ein flaches Pattern bindet die beiden Point-Komponenten, lässt sie aber als Ganzes bestehen.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Object obj = new Line(new Point(0, 0), new Point(3, 4));
        if (obj instanceof Line(Point s, Point e)) {
            System.out.println(s + " -> " + e);
        }
    }
}

Tiefer gehen

Ersetzen Sie den inneren Point s durch sein eigenes Record-Pattern, um direkt auf die Koordinaten zuzugreifen: Line(Point(int x1, int y1), Point(int x2, int y2)).

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    public static void main(String[] args) {
        Object obj = new Line(new Point(0, 0), new Point(3, 4));
        if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
            double len = Math.hypot(x2 - x1, y2 - y1);
            System.out.println("Length: " + len);
        }
    }
}

Beliebige Tiefe

Die Verschachtelung kann so tief gehen wie Ihre Datenstruktur. Jede Ebene bindet entweder eine vollständige Komponente oder destrukturiert sie weiter, sodass die Form der Struktur exakt abgebildet wird.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}
    record Drawing(Line first, String label) {}

    public static void main(String[] args) {
        Object obj = new Drawing(new Line(new Point(1, 2), new Point(3, 4)), "diag");
        if (obj instanceof Drawing(Line(Point(var ax, var ay), var end), var label)) {
            System.out.println(label + " starts at " + ax + "," + ay);
            System.out.println("ends near " + end);
        }
    }
}

var und Typen kombinieren

Innerhalb eines verschachtelten Patterns können Sie explizite Typen und var frei kombinieren. Verwenden Sie var für Komponenten, die Sie nur weiterreichen, und explizite Typen dort, wo sie die Klarheit erhöhen.

Verschachtelung in switch

Verschachtelte Patterns sind besonders ausdrucksstark in switch, da jeder case-Zweig eine präzise Datenstruktur beschreiben kann.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static String describe(Object o) {
        return switch (o) {
            case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 -> "vertical";
            case Line(Point p1, Point p2) -> "general line";
            default -> "not a line";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Line(new Point(2, 0), new Point(2, 9))));
        System.out.println(describe(new Line(new Point(0, 0), new Point(5, 5))));
    }
}

Das gesamte Pattern muss passen

Ein verschachteltes Pattern passt nur, wenn jede Ebene passt. Wenn eine Komponente einen anderen Typ hat als vom Sub-Pattern erwartet, schlägt der gesamte Match fehl und es werden keine Variablen gebunden.

Kompromiss bei der Lesbarkeit

Tiefe Verschachtelungen sind mächtig, können aber schwer lesbar werden. Wenn ein Pattern zu groß wird, sollten Sie eine Ebene destrukturieren und den Rest mit separater Logik verarbeiten.

Guards für verschachtelte Bindungen

Da verschachtelte Patterns innere Werte als lokale Variablen verfügbar machen, kann ein einzelner when-Guard Felder aus mehreren Ebenen gleichzeitig referenzieren.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static boolean isUnitStep(Object o) {
        return o instanceof Line(Point(int x1, int y1), Point(int x2, int y2))
            && x2 - x1 == 1 && y2 - y1 == 1;
    }

    public static void main(String[] args) {
        System.out.println(isUnitStep(new Line(new Point(0, 0), new Point(1, 1))));
        System.out.println(isUnitStep(new Line(new Point(0, 0), new Point(2, 2))));
    }
}

Ein vollständiges Beispiel

Berechnen Sie den Mittelpunkt einer Linie, indem Sie beide Endpunkte destrukturieren.

public class Main {
    record Point(int x, int y) {}
    record Line(Point start, Point end) {}

    static Point midpoint(Object o) {
        if (o instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
            return new Point((x1 + x2) / 2, (y1 + y2) / 2);
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(midpoint(new Line(new Point(0, 0), new Point(4, 6))));
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von verschachtelten Record-Patterns.

Zusammenfassung

Sie haben verschachtelte Record-Patterns gelernt.

Eine Record-Komponente, die selbst ein Record ist, kann direkt im Pattern destrukturiert werden.
Die Verschachtelung kann beliebig tief gehen und explizite Typen mit var kombinieren.
Der Match ist nur erfolgreich, wenn jede Ebene passt.
Innere Bindungen können gemeinsam in Guards und im Rumpf verwendet werden.

Häufig gestellte Fragen

Ist die Lektion „Verschachtelte Record Patterns“ kostenlos?

Ja — der vollständige Text von „Verschachtelte Record Patterns“ 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 „Verschachtelte Record Patterns“?

Tief verschachtelte Daten abgleichen 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 3 von 4.

Wie lange dauert die Lektion „Verschachtelte Record Patterns“?

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