Introducing Records
Declare records as concise immutable data holders and understand their auto-generated members.
Introducing Records is a free Java Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Java Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Introducing Records
Java Records (Java 16+) are a concise way to declare immutable data carrier classes. They auto-generate boilerplate: constructor, getters, equals, hashCode, and toString.
Declaring a Record
Use the record keyword followed by the record name and a component list. Each component becomes a private final field and a public accessor method.
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))); // trueAuto-Generated Members
The compiler automatically generates for every record: canonical constructor, public accessors, equals(), hashCode(), toString(). No need to write these manually.
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 are Immutable
Record components are final. You cannot modify them after construction — records model immutable value objects.
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 Extend Object Only
Records implicitly extend java.lang.Record and cannot extend other classes. They can implement interfaces.
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.54Records in Collections
Because records properly implement equals and hashCode based on all components, they work correctly as Map keys and Set elements.
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))); // trueRecords as DTOs
Records are ideal for Data Transfer Objects (DTOs) in REST APIs — they carry data between layers without behavior.
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);Deconstructing Records
Records pair well with pattern matching. You can deconstruct them in switch expressions (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.00Record Serialization
Records implement Serializable naturally when declared to. They work well with JSON libraries (Jackson, Gson) out of the box.
// 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)); // trueNested Records
Records can contain other records as components, building rich immutable object graphs.
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]]Records Limitations
Records have some restrictions to be aware of:
- Cannot extend other classes (implicitly extends Record)
- Components are always final — no mutable state
- Cannot declare instance fields outside the component list
- Cannot be abstract
// 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]Quick Check
Which members does the Java compiler automatically generate for a record?
Recap: Introducing Records
Key takeaways:
- Records declare immutable data carriers with minimal boilerplate
- Auto-generated: canonical constructor, accessors, equals, hashCode, toString
- Components are final — records are immutable by design
- Records can implement interfaces but cannot extend classes
- Perfect for DTOs, value objects, and API responses
- Works correctly as HashMap keys and HashSet elements due to structural equality
Frequently asked questions
Is the “Introducing Records” lesson free?
Yes — the full text of “Introducing Records” is free to read here on the web, and the Java Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Java Academy course, upgrade to CoddyKit PRO.
What will I learn in “Introducing Records”?
Declare records as concise immutable data holders and understand their auto-generated members. You practise Java Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Java Academy?
No prior experience is required. Java Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Introducing Records” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Java Academy lesson?
Yes. Every Java Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.