Java Academy · Lektion

Records kennenlernen

Deklarieren Sie Records als kompakte unveränderliche Datenträger und verstehen Sie ihre automatisch generierten Member.

Records kennenlernen 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.

Records einführen

Java-Records (ab Java 16) bieten eine kompakte Möglichkeit, unveränderliche Datencontainerklassen zu deklarieren. Sie erzeugen automatisch den Boilerplate-Code für Konstruktor, Zugriffsmethoden, equals, hashCode und toString.

Einen Record deklarieren

Verwenden Sie das Schlüsselwort record, gefolgt vom Namen des Records und einer Komponentenliste. Jede Komponente wird zu einem privaten finalen Feld und einer öffentlichen Zugriffsmethode.

record Point(double x, double y) {}

Point p = new Point(3.0, 4.0);
System.out.println(p.x());      // 3.0 (accessor, not getX())
System.out.println(p.y());      // 4.0
System.out.println(p);          // Point[x=3.0, y=4.0]
System.out.println(p.equals(new Point(3.0, 4.0))); // true

Automatisch generierte Member

Der Compiler generiert automatisch für jeden Record: kanonischen Konstruktor, öffentliche Zugriffsmethoden, equals(), hashCode() und toString(). Sie müssen diese nicht von Hand schreiben.

record Product(String name, double price, int stock) {}

Product p1 = new Product("Widget", 9.99, 100);
Product p2 = new Product("Widget", 9.99, 100);

System.out.println(p1.name());          // Widget
System.out.println(p1.price());         // 9.99
System.out.println(p1.equals(p2));      // true (structural)
System.out.println(p1.hashCode() == p2.hashCode()); // true
System.out.println(p1);                 // Product[name=Widget, price=9.99, stock=100]

Records sind unveränderlich

Record-Komponenten sind final. Nach der Erstellung können Sie sie nicht mehr ändern – Records bilden unveränderliche Wertobjekte ab.

record Money(long cents, String currency) {}

Money price = new Money(999, "USD");
// price.cents = 500; // Compile error — final field!

// To "update" a record, create a new one
Money discounted = new Money(price.cents() - 100, price.currency());
System.out.println(discounted); // Money[cents=899, currency=USD]

Records erweitern nur Object

Records erweitern implizit java.lang.Record und können keine anderen Klassen erweitern. Sie können jedoch Interfaces implementieren.

interface Describable { String describe(); }

record Circle(double radius) implements Describable {
    public String describe() {
        return String.format("Circle with radius %.1f", radius);
    }

    public double area() {
        return Math.PI * radius * radius;
    }
}

Circle c = new Circle(5.0);
System.out.println(c.describe()); // Circle with radius 5.0
System.out.printf("Area: %.2f%n", c.area()); // Area: 78.54

Records in Collections

Da Records equals und hashCode auf Grundlage aller Komponenten korrekt implementieren, funktionieren sie zuverlässig als Map-Schlüssel und Set-Elemente.

import java.util.*;

record Coordinate(int row, int col) {}

Map<Coordinate, String> grid = new HashMap<>();
grid.put(new Coordinate(0, 0), "Origin");
grid.put(new Coordinate(1, 2), "Target");

// Lookup with equal-valued record works correctly
System.out.println(grid.get(new Coordinate(0, 0))); // Origin
System.out.println(grid.get(new Coordinate(1, 2))); // Target

Set<Coordinate> visited = new HashSet<>();
visited.add(new Coordinate(3, 3));
System.out.println(visited.contains(new Coordinate(3, 3))); // true

Records als DTOs

Records eignen sich ideal als Data Transfer Objects (DTOs) in REST-APIs – sie transportieren Daten zwischen Schichten, ohne Verhalten zu enthalten.

record CreateUserRequest(String email, String displayName, String plan) {}

record UserResponse(long id, String email, String displayName,
                    String plan, String createdAt) {}

// Simulating a service call
static UserResponse createUser(CreateUserRequest req) {
    long id = 42L;
    return new UserResponse(id, req.email(), req.displayName(),
        req.plan(), java.time.Instant.now().toString());
}

CreateUserRequest req = new CreateUserRequest("alice@example.com", "Alice", "PRO");
UserResponse resp = createUser(req);
System.out.println(resp);

Records dekonstruieren

Records lassen sich gut mit Pattern Matching kombinieren. Sie können sie in Switch-Ausdrücken dekonstruieren (ab Java 21).

sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
record Triangle(double base, double height) implements Shape {}

static double area(Shape s) {
    return switch (s) {
        case Circle(double r)            -> Math.PI * r * r;
        case Rectangle(double w, double h) -> w * h;
        case Triangle(double b, double h) -> 0.5 * b * h;
    };
}

System.out.printf("%.2f%n", area(new Circle(5)));         // 78.54
System.out.printf("%.2f%n", area(new Rectangle(4, 6)));   // 24.00

Record-Serialisierung

Records implementieren Serializable problemlos, wenn sie entsprechend deklariert sind. Sie funktionieren ohne zusätzliche Konfiguration gut mit JSON-Bibliotheken wie Jackson und Gson.

// With Jackson (add @JsonProperty if needed)
import com.fasterxml.jackson.databind.ObjectMapper;

record OrderSummary(String orderId, double total, String status) {}

ObjectMapper mapper = new ObjectMapper();
OrderSummary order = new OrderSummary("ORD-001", 149.99, "SHIPPED");

String json = mapper.writeValueAsString(order);
System.out.println(json);
// {"orderId":"ORD-001","total":149.99,"status":"SHIPPED"}

OrderSummary restored = mapper.readValue(json, OrderSummary.class);
System.out.println(order.equals(restored)); // true

Verschachtelte Records

Records können andere Records als Komponenten enthalten und so komplexe unveränderliche Objektgraphen bilden.

record Address(String street, String city, String country) {}
record Customer(long id, String name, Address address) {}

Address addr = new Address("123 Main St", "New York", "US");
Customer customer = new Customer(1L, "Alice", addr);

System.out.println(customer.name());              // Alice
System.out.println(customer.address().city());   // New York
System.out.println(customer);                    // Customer[id=1, name=Alice, address=Address[street=123 Main St, city=New York, country=US]]

Einschränkungen von Records

Bei Records gibt es einige Einschränkungen, die Sie beachten sollten:

Sie können keine anderen Klassen erweitern (sie erweitern implizit Record)
Komponenten sind immer final – es gibt keinen veränderlichen Zustand
Außerhalb der Komponentenliste können keine Instanzfelder deklariert werden
Records können nicht abstrakt sein

// Records CAN have static fields and methods
record Temperature(double celsius) {
    static final double ABSOLUTE_ZERO = -273.15;

    public double toFahrenheit() {
        return celsius * 9.0/5.0 + 32;
    }

    public static Temperature fromFahrenheit(double f) {
        return new Temperature((f - 32) * 5.0/9.0);
    }
}
System.out.println(Temperature.fromFahrenheit(98.6)); // Temperature[celsius=37.0]

Kurztest

Welche Member generiert der Java-Compiler automatisch für einen Record?

Zusammenfassung: Records einführen

Die wichtigsten Erkenntnisse:

Records deklarieren unveränderliche Datencontainer mit minimalem Boilerplate-Code
Automatisch generiert werden: kanonischer Konstruktor, Zugriffsmethoden, equals, hashCode und toString
Komponenten sind final – Records sind von Grund auf unveränderlich
Records können Interfaces implementieren, aber keine Klassen erweitern
Sie eignen sich ideal für DTOs, Wertobjekte und API-Antworten
Dank struktureller Gleichheit funktionieren sie korrekt als HashMap-Schlüssel und HashSet-Elemente

Häufig gestellte Fragen

Ist die Lektion „Records kennenlernen“ kostenlos?

Ja — der vollständige Text von „Records kennenlernen“ 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 „Records kennenlernen“?

Deklarieren Sie Records als kompakte unveränderliche Datenträger und verstehen Sie ihre automatisch generierten Member. 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 „Records kennenlernen“?

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