Record Patterns
Records in Patterns dekonstruieren
Record Patterns ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.
Record-Patterns
Ein Record-Pattern prüft einen Record und destrukturiert ihn, indem es seine Komponenten in einem Schritt an Variablen bindet. Sie müssen nicht mehr jeden Accessor von Hand aufrufen.
Ein Record zum Destrukturieren
Beginnen Sie mit einem einfachen Record. Seine Komponenten sind die Werte, die ein Pattern extrahieren kann.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Point p = new Point(3, 4);
System.out.println(p.x() + ", " + p.y());
}
}Destrukturierung mit instanceof
Anstatt instanceof Point p und anschließend p.x() zu schreiben, schreiben Sie instanceof Point(int x, int y), um x und y direkt zu binden.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Object obj = new Point(3, 4);
if (obj instanceof Point(int x, int y)) {
System.out.println("Sum: " + (x + y));
}
}
}Komponenten werden zu lokalen Variablen
Die Namen innerhalb des Patterns (x, y) sind neue lokale Variablen, die die Werte der Record-Komponenten enthalten. Sie wählen die Namen selbst; sie müssen nicht mit den Namen des Records übereinstimmen.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Object obj = new Point(10, 20);
if (obj instanceof Point(int a, int b)) {
System.out.println("a=" + a + " b=" + b);
}
}
}var in Patterns verwenden
Sie können für eine Komponente var schreiben, damit der Compiler ihren Typ ableitet. Das ist praktisch, wenn die Typen lang sind.
public class Main {
record Pair(String key, Integer value) {}
public static void main(String[] args) {
Object obj = new Pair("age", 30);
if (obj instanceof Pair(var key, var value)) {
System.out.println(key + " = " + value);
}
}
}Patterns in switch
Record-Patterns funktionieren auch in switch, sodass die case-Zweige wie Datenstrukturen aussehen.
public class Main {
record Point(int x, int y) {}
static String classify(Object obj) {
return switch (obj) {
case Point(int x, int y) when x == y -> "on diagonal";
case Point(int x, int y) -> "at " + x + "," + y;
default -> "not a point";
};
}
public static void main(String[] args) {
System.out.println(classify(new Point(5, 5)));
System.out.println(classify(new Point(1, 2)));
}
}Typinferenz beim Matching
Die Komponententypen im Pattern müssen mit den deklarierten Typen des Records kompatibel sein. Der exakte Typ oder var ist die sichere Wahl.
Mit Guards kombinieren
Fügen Sie nach einem Record-Pattern einen when-Guard hinzu, um nur dann zu matchen, wenn die destrukturierten Werte eine Bedingung erfüllen.
public class Main {
record Temperature(double celsius) {}
static String alert(Object o) {
if (o instanceof Temperature(double c) && c > 38.0) {
return "fever: " + c;
}
return "normal";
}
public static void main(String[] args) {
System.out.println(alert(new Temperature(39.5)));
System.out.println(alert(new Temperature(36.6)));
}
}Übersichtlicher Datenzugriff
Record-Patterns spielen ihre Stärke aus, wenn Sie nur einige wenige Felder benötigen. Sie beseitigen eine Kette von Accessor-Aufrufen und machen die relevanten Daten direkt an der Match-Stelle sichtbar.
null und Record-Patterns
Wie alle instanceof-Patterns ist ein Record-Pattern für null false. Die Destrukturierung findet erst statt, wenn bestätigt ist, dass der Wert eine nicht-null Instanz des Records ist.
Ein praktisches Beispiel
Destrukturieren Sie die Komponenten, um direkt daraus einen Wert zu berechnen.
public class Main {
record Rectangle(int width, int height) {}
static int area(Object o) {
if (o instanceof Rectangle(int w, int h)) {
return w * h;
}
return 0;
}
public static void main(String[] args) {
System.out.println(area(new Rectangle(4, 5)));
System.out.println(area("not a rect"));
}
}Kurzer Test
Testen Sie Ihr Verständnis von Record-Patterns.
Zusammenfassung
Sie haben Record-Patterns gelernt.
- Sie prüfen den Record-Typ und destrukturieren seine Komponenten gleichzeitig.
- Die Komponentennamen sind neue lokale Variablen, die Sie selbst wählen; mit
varwerden die Typen abgeleitet. - Sie funktionieren sowohl in
instanceofals auch inswitch. - Wie alle Patterns sind sie für null false.
Häufig gestellte Fragen
Ist die Lektion „Record Patterns“ kostenlos?
Ja — der vollständige Text von „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 „Record Patterns“?
Records in Patterns dekonstruieren 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 2 von 4.
Wie lange dauert die Lektion „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.