Record-mönster
Destrukturera records i mönster.
Record-mönster är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.
Record-mönster
Ett record-mönster matchar ett record och destrukturerar det genom att binda dess komponenter till variabler i ett enda steg. Ni behöver inte längre anropa varje accessor manuellt.
Ett record att destrukturera
Börja med ett enkelt record. Dess komponenter är sådant som ett mönster kan extrahera.
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());
}
}Destrukturering med instanceof
I stället för instanceof Point p och sedan p.x() kan ni skriva instanceof Point(int x, int y) för att binda x och y direkt.
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));
}
}
}Komponenter blir lokala variabler
Namnen i mönstret (x, y) är nya lokala variabler som innehåller recordets komponentvärden. Ni väljer namnen själva; de behöver inte överensstämma med recordet.
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);
}
}
}Använda var i mönster
Ni kan skriva var för en komponent och låta kompilatorn härleda dess typ, vilket är praktiskt när typerna är långa.
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);
}
}
}Mönster i switch
Record-mönster fungerar även i switch, vilket gör att case-grenarna kan läsas som datastrukturer.
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)));
}
}Matchning med typinferens
Komponenttyperna i mönstret måste vara kompatibla med recordets deklarerade typer. Det säkra valet är att använda den exakta typen eller var.
Kombinera med villkor
Lägg till ett when-villkor efter ett record-mönster för att matcha endast när de destrukturerade värdena uppfyller ett villkor.
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)));
}
}Renare dataåtkomst
Record-mönster är särskilt användbara när ni bara behöver ett par fält. De eliminerar en kedja av accessor-anrop och gör den relevanta datan tydlig direkt vid matchningen.
Null och record-mönster
Precis som alla instanceof-mönster är ett record-mönster false för null. Destruktureringen sker först när värdet har bekräftats vara en instans av recordet som inte är null.
Ett praktiskt exempel
Destrukturera för att beräkna ett värde direkt från komponenterna.
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"));
}
}Snabbtest
Testa er förståelse av record-mönster.
Sammanfattning
Ni har lärt er record-mönster.
- De testar om en typ är ett record och destrukturerar dess komponenter samtidigt.
- Komponentnamnen är nya lokala variabler som ni väljer själva;
varhärleder typerna. - De fungerar både i
instanceofochswitch. - Precis som alla mönster är de false för null.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Record-mönster” gratis?
Ja – hela texten till ”Record-mönster” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Record-mönster”?
Destrukturera records i mönster. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”Record-mönster”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.