Java Academy · Lezione

Introduzione ai record

Dichiari i record come contenitori concisi e immutabili di dati e comprenda i relativi membri generati automaticamente.

Introduzione ai record è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Introduzione ai record

I record Java (Java 16+) sono un modo conciso per dichiarare classi immutabili contenitore di dati. Generano automaticamente il codice ripetitivo: costruttore, metodi di accesso, equals, hashCode e toString.

Dichiarare un record

Utilizzi la parola chiave record seguita dal nome del record e dall'elenco dei componenti. Ogni componente diventa un campo private final e un metodo di accesso pubblico.

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

Membri generati automaticamente

Il compilatore genera automaticamente per ogni record: costruttore canonico, metodi di accesso pubblici, equals(), hashCode() e toString(). Non è necessario scriverli manualmente.

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]

I record sono immutabili

I componenti dei record sono final. Non è possibile modificarli dopo la costruzione: i record rappresentano oggetti valore immutabili.

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]

I record estendono solo Object

I record estendono implicitamente java.lang.Record e non possono estendere altre classi. Possono implementare interfacce.

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

I record nelle collezioni

Poiché i record implementano correttamente equals e hashCode sulla base di tutti i componenti, possono essere utilizzati correttamente come chiavi di Map ed elementi di Set.

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

I record come DTO

I record sono ideali per i Data Transfer Object (DTO) nelle API REST: trasportano dati tra i livelli senza contenere comportamento.

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

Decostruire i record

I record si combinano bene con il pattern matching. È possibile decostruirli nelle espressioni switch (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

Serializzazione dei record

I record possono implementare Serializable in modo naturale quando lo si dichiara esplicitamente. Funzionano bene con le librerie JSON (Jackson, Gson) senza configurazione aggiuntiva.

// 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

Record annidati

I record possono contenere altri record come componenti, creando grafi di oggetti immutabili complessi.

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]]

Limitazioni dei record

È importante conoscere alcune limitazioni dei record:

Non possono estendere altre classi (estendono implicitamente Record)
I componenti sono sempre final: non è possibile avere stato mutabile
Non è possibile dichiarare campi di istanza al di fuori dell'elenco dei componenti
Non possono essere astratti

// 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]

Verifica rapida

Quali membri genera automaticamente il compilatore Java per un record?

Riepilogo: introduzione ai record

Punti chiave:

I record dichiarano contenitori di dati immutabili con un minimo di codice ripetitivo
Generati automaticamente: costruttore canonico, metodi di accesso, equals, hashCode e toString
I componenti sono final: i record sono immutabili per progettazione
I record possono implementare interfacce, ma non possono estendere classi
Sono perfetti per DTO, oggetti valore e risposte delle API
Funzionano correttamente come chiavi di HashMap ed elementi di HashSet grazie all'uguaglianza strutturale

Domande Frequenti

La lezione «Introduzione ai record» è gratuita?

Sì — il testo completo di «Introduzione ai record» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Introduzione ai record»?

Dichiari i record come contenitori concisi e immutabili di dati e comprenda i relativi membri generati automaticamente. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Introduzione ai record»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy