Apa itu records dan sealed classes?

Question

Accepted Answer

**Records** (Java 16+) adalah pembawa data ringkas dan immutable yang secara otomatis menghasilkan boilerplate, dan **sealed classes** (Java 17+) membatasi kelas mana yang dapat memperluas/mengimplementasikan suatu tipe. Keduanya adalah fitur modern yang membuat Java lebih ekspresif dan memungkinkan pemodelan yang lebih baik.

## Records — data immutable, tanpa boilerplate

```java
// ❌ a traditional data class needs ~40 lines of boilerplate
// (fields, constructor, getters, equals, hashCode, toString)

// ✅ a record generates ALL of that automatically
public record Point(int x, int y) {}

Point p = new Point(3, 4);
p.x();              // 3 — accessor (note: x(), not getX())
p.equals(new Point(3, 4));   // true — equals() generated
p;                  // Point[x=3, y=4] — toString() generated
p.hashCode();       // generated, consistent with equals
```

Sebuah record secara otomatis menghasilkan konstruktor, accessor, `equals()`, `hashCode()`, dan `toString()` dari komponen-komponennya. Field-field tersebut **final** (immutable) — records dirancang untuk pembawa data yang transparan dan immutable (DTOs, value objects, koordinat).

## Records dapat memiliki validasi dan metode

```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; }  // can add methods
}
```

## Sealed classes — warisan terkontrol

```java
// restrict WHO can extend/implement — only the named classes
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; }
// no other class can implement Shape
```

Sebuah tipe `sealed` secara eksplisit mencantumkan subtipe-subtipe yang diizinkannya — Anda mengendalikan set lengkap implementasi, yang diberlakukan oleh compiler. Ini memodelkan **hierarki tertutup** (set varian yang tetap dan diketahui).

## Sealed + records + pattern matching = pemodelan yang kuat

```java
// the compiler KNOWS all the cases → exhaustive switch (no default needed)
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();
    // no default needed — sealed guarantees these are ALL the cases
};
```

Karena subtipe dari tipe sealed diketahui dan terbatas, compiler dapat memverifikasi bahwa `switch` adalah **exhaustive** — menangkap kasus yang hilang. Dikombinasikan dengan records dan pattern matching, ini membawa gaya pemodelan algebraic-data-type ke Java.

## Mengapa ini penting

Records dan sealed classes adalah fitur Java modern yang signifikan untuk meningkatkan ekspresivitas dan keamanan. **Records** menghilangkan boilerplate yang membosankan dan rawan kesalahan dari kelas data (dan menjamin `equals`/`hashCode` yang benar dan konsisten — menyelesaikan pitfall umum itu) sambil memberlakukan immutability — membuat DTOs, value objects, dan pemodelan data jauh lebih bersih. **Sealed classes** memungkinkan hierarki tipe tertutup dan terkontrol yang dipahami compiler, yang — dikombinasikan dengan records dan pattern-matching `switch` — memungkinkan penanganan exhaustive dan type-safe dari set varian yang tetap (algebraic data types).

Bersama-sama mereka membuat Java lebih ringkas, immutable-by-default, dan mampu pemodelan domain yang lebih aman.

Mengetahuinya mencerminkan kelancaran dengan Java saat ini dan memungkinkan desain yang lebih bersih dan lebih robust yang memerlukan jauh lebih banyak kode di Java yang lebih lama untuk dicapai.