Apa iku records lan sealed classes?

Question

Accepted Answer

**Records** (Java 16+) minangka data carriers sing ringkas, immutable, lan auto-generate boilerplate, lan **sealed classes** (Java 17+) mbatesi kelas mana wae sing bisa extend/implement sawijining tipe. Loro-lorone minangka fitur modern sing nggawe Java luwih ekspresif lan ngowahi modeling sing luwih apik.

## Records — data immutable, nol 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
```

A record auto-generate constructor, accessors, `equals()`, `hashCode()`, lan `toString()` saka components-ne. Fields-ne **final** (immutable) — records dirancang kanggo transparent, immutable data carriers (DTOs, value objects, coordinates).

## Records bisa duwe validation lan methods

```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 — controlled inheritance

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

A `sealed` type kanthi eksplisit daftar permitted subtypes-ne — sampeyan ngontrol set lengkap saka implementations, sing compiler enforce. Iki nggawe model **closed hierarchy** (sawijining set sing fixed, known saka variants).

## Sealed + records + pattern matching = powerful modeling

```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 subtypes saka sealed type dikenal lan finite, compiler bisa verify `switch` iku **exhaustive** — nangkep missing cases. Digabung karo records lan pattern matching, iki nggawa algebraic-data-type style modeling menyang Java.

## Mulane penting

Records lan sealed classes minangka fitur Java modern sing signifikan sing nambah expressiveness lan safety. **Records** ilang boilerplate sing tedious, error-prone saka data classes (lan garanteni correct, consistent `equals`/`hashCode` — ngatasi pitfall sing umum) nalika enforce immutability — nggawe DTOs, value objects, lan data modeling luwih rapi. **Sealed classes** ngowahi closed, controlled type hierarchies sing compiler ngerti, sing — digabung karo records lan pattern-matching `switch` — ngidini exhaustive, type-safe handling saka set fixed saka variants (algebraic data types).

Bareng-bareng biyen nggawe Java luwih ringkas, immutable-by-default, lan mampu saka safer domain modeling.

Ngerti-ngerti loro-lorone nggambarake fluency karo Java contemporary lan ngowahi cleaner, robust designs sing Java lawas mbutuhke akeh banget code kanggo achieve.