Java Academy · Lektion

Nästande record-mönster

Matcha djupt nästlade data.

Lektion 3 av 413 steg

Nästande record-mönster är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 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.

Kapslade record-mönster

Record-mönster kan kapslas: en komponent som själv är ett record kan destruktureras inuti det yttre mönstret. På så sätt kan djupt strukturerad data matchas i ett enda uttryck.

En kapslad datamodell

Föreställ er ett Line som består av två Point-record. De inre recorden är naturliga kandidater för kapsling.

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);
    }
}

Destrukturering på en nivå

Ett platt mönster binder de två Point-komponenterna men lämnar dem intakta.

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);
        }
    }
}

Gå djupare

Ersätt det inre Point s med dess eget record-mönster för att nå koordinaterna direkt: 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);
        }
    }
}

Valfritt djup

Kapslingen kan gå så djupt som era data kräver. Varje nivå binder antingen en hel komponent eller destrukturerar den ytterligare, så att datastrukturens form avspeglas exakt.

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);
        }
    }
}

Blanda var och typer

I ett kapslat mönster kan ni fritt blanda explicita typer och var. Använd var för komponenter som ni bara skickar vidare och explicita typer där det förbättrar tydligheten.

Kapsling i switch

Kapslade mönster är särskilt uttrycksfulla i switch, eftersom varje case kan beskriva en exakt datastruktur.

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))));
    }
}

Hela matchningen måste lyckas

Ett kapslat mönster matchar endast om varje nivå matchar. Om någon komponent har en annan typ än vad dess undermönster förväntar sig misslyckas hela matchningen, och inga variabler binds.

Avvägning för läsbarheten

Djup kapsling är kraftfull men kan bli svårläst. Om ett mönster blir för stort kan ni överväga att destrukturera en nivå och hantera resten med separat logik.

Villkor över kapslade bindningar

Eftersom kapslade mönster exponerar inre värden som lokala variabler kan ett enda when-villkor referera till fält från flera nivåer samtidigt.

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))));
    }
}

Ett komplett exempel

Beräkna mittpunkten på en linje genom att destrukturera båda ändpunkterna.

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))));
    }
}

Snabbtest

Testa er förståelse av kapslade record-mönster.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er kapslade record-mönster.

En record-komponent som själv är ett record kan destruktureras direkt i mönstret.
Kapslingen kan gå till valfritt djup och blanda explicita typer med var.
Matchningen lyckas endast om varje nivå matchar.
Inre bindningar kan användas både i villkor och i kodblocket.

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Nästande record-mönster” gratis?

Ja – hela texten till ”Nästande 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 ”Nästande record-mönster”?

Matcha djupt nästlade data. 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 3 av 4.

Hur lång tid tar lektionen ”Nästande 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.

Alla lektioner i den här kursen

← Tillbaka till Java Academy