Records na sealed classes ni nini?

Question

Accepted Answer

**Records** (Java 16+) ni wabebaji wa data wafupi, wasiobadilika ambao huzalisha boilerplate kiotomatiki, na **sealed classes** (Java 17+) huzuia ni classes zipi zinaweza kupanua/kutekeleza aina. Vyote ni vipengele vya kisasa vinavyofanya Java kuwa ya kueleweka zaidi na kuwezesha modeling bora.

## Records — data isiyobadilika, sifuri 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
```

Record huzalisha kiotomatiki constructor, accessors, `equals()`, `hashCode()`, na `toString()` kutoka kwa vipengele vyake. Fields ni **final** (zisizobadilika) — records zimeundwa kwa ajili ya wabebaji wa data walio wazi, wasiobadilika (DTOs, value objects, coordinates).

## Records zinaweza kuwa na validation na 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 — inheritance inayodhibitiwa

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

Aina ya `sealed` huorodhesha kwa uwazi subtypes zinazoruhusiwa — wewe hudhibiti seti kamili ya utekelezaji, ambayo compiler hulazimisha. Hii hu-model **closed hierarchy** (seti isiyobadilika, inayojulikana ya variants).

## Sealed + records + pattern matching = modeling yenye nguvu

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

Kwa sababu subtypes za aina ya sealed zinajulikana na ni za mwisho, compiler inaweza kuthibitisha kuwa `switch` ni **exhaustive** — ikikamata cases zilizokosekana. Ikiunganishwa na records na pattern matching, hii huleta modeling ya mtindo wa algebraic-data-type kwenye Java.

## Kwa nini ni muhimu

Records na sealed classes ni vipengele muhimu vya Java vya kisasa vinavyoboresha ueleweka na usalama. **Records** huondoa boilerplate ya kuchosha, yenye makosa ya data classes (na kuhakikisha `equals`/`hashCode` sahihi, thabiti — kutatua tatizo lile la kawaida) huku zikilazimisha immutability — kufanya DTOs, value objects, na data modeling kuwa safi zaidi. **Sealed classes** huwezesha hierarchies za aina zilizofungwa, zinazodhibitiwa ambazo compiler inaelewa, ambazo — zikiunganishwa na records na pattern-matching `switch` — huruhusu ushughulikiaji wa exhaustive, salama wa aina kwa seti isiyobadilika ya variants (algebraic data types).

Kwa pamoja zinafanya Java kuwa fupi zaidi, isiyobadilika-kwa-chaguo-msingi, na yenye uwezo wa domain modeling salama zaidi.

Kuzijua kunaonyesha umahiri wa Java ya sasa na huwezesha miundo safi, imara zaidi ambayo Java ya zamani ilihitaji msimbo mwingi zaidi kufikia.