Record và sealed class là gì?

Question

Accepted Answer

**Record** (Java 16+) là những bộ chứa dữ liệu ngắn gọn, immutable, tự động sinh boilerplate, và **sealed class** (Java 17+) hạn chế những class nào có thể extend/implement một type. Cả hai đều là các tính năng hiện đại làm cho Java giàu sức biểu đạt hơn và cho phép modeling tốt hơn.

## Record — dữ liệu immutable, không boilerplate

```java
// ❌ một data class truyền thống cần ~40 dòng boilerplate
// (field, constructor, getter, equals, hashCode, toString)

// ✅ một record sinh TẤT CẢ những thứ đó một cách tự động
public record Point(int x, int y) {}

Point p = new Point(3, 4);
p.x();              // 3 — accessor (lưu ý: x(), không phải getX())
p.equals(new Point(3, 4));   // true — equals() được sinh ra
p;                  // Point[x=3, y=4] — toString() được sinh ra
p.hashCode();       // được sinh ra, nhất quán với equals
```

Một record tự động sinh constructor, accessor, `equals()`, `hashCode()`, và `toString()` từ các component của nó. Các field là **final** (immutable) — record được thiết kế làm bộ chứa dữ liệu immutable, minh bạch (DTO, value object, tọa độ).

## Record có thể có validation và method

```java
public record Range(int min, int max) {
    public Range {                          // compact constructor — validate
        if (min > max) throw new IllegalArgumentException("min > max");
    }
    public int size() { return max - min; }  // có thể thêm method
}
```

## Sealed class — kế thừa có kiểm soát

```java
// hạn chế AI có thể extend/implement — chỉ những class được nêu tên
public sealed interface Shape permits Circle, Square, Triangle {}

public final class Circle implements Shape { double radius; }
public final class Square implements Shape { double side; }
public final class Triangle implements Shape { double base, height; }
// không class nào khác có thể implement Shape
```

Một type `sealed` liệt kê tường minh các subtype được phép — bạn kiểm soát toàn bộ tập các implementation, và compiler thực thi điều đó. Điều này mô hình hóa một **closed hierarchy** (một tập biến thể cố định, đã biết).

## Sealed + record + pattern matching = modeling mạnh mẽ

```java
// compiler BIẾT mọi case → switch vét cạn (không cần default)
double area = switch (shape) {
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Square s -> s.side() * s.side();
    case Triangle t -> 0.5 * t.base() * t.height();
    // không cần default — sealed đảm bảo đây là TẤT CẢ các case
};
```

Vì các subtype của một sealed type là đã biết và hữu hạn, compiler có thể xác minh rằng một `switch` là **vét cạn** — bắt được các case bị thiếu. Kết hợp với record và pattern matching, điều này mang lại phong cách modeling kiểu algebraic data type cho Java.

## Tại sao điều này quan trọng

Record và sealed class là những tính năng Java hiện đại quan trọng giúp cải thiện sức biểu đạt và độ an toàn. **Record** loại bỏ boilerplate tẻ nhạt, dễ lỗi của các data class (và đảm bảo `equals`/`hashCode` đúng đắn, nhất quán — giải quyết cái pitfall phổ biến đó) trong khi thực thi tính immutable — làm cho DTO, value object, và data modeling sạch hơn nhiều. **Sealed class** cho phép các type hierarchy đóng, có kiểm soát mà compiler hiểu được, và — kết hợp với record và pattern-matching `switch` — cho phép xử lý vét cạn, type-safe một tập biến thể cố định (algebraic data type).

Cùng nhau, chúng làm cho Java ngắn gọn hơn, immutable-by-default, và có khả năng modeling domain an toàn hơn.

Biết chúng phản ánh sự thông thạo Java hiện đại và cho phép các thiết kế sạch hơn, vững chắc hơn mà Java cũ đòi hỏi nhiều code hơn nhiều mới đạt được.