Što su zapisi i zapečaćene klase?

Question

Accepted Answer

**Zapisi** (Java 16+) su sažeti, nepromjenjivi nosači podataka koji automatski generiraju stereotipan kod, a **zapečaćene klase** (Java 17+) ograničavaju koje klase mogu proširiti/implementirati tip. Obje su moderne značajke koje čine Java izrazitijom i omogućavaju bolje modeliranje.

## Zapisi — nepromjenjivi podaci, bez stereotipnog koda

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

Zapis automatski generira konstruktor, pristupnike, `equals()`, `hashCode()` i `toString()` iz svojih komponenti. Polja su **final** (nepromjenjiva) — zapisi su dizajnirani kao transparentni, nepromjenjivi nosači podataka (DTOvi, objekti vrijednosti, koordinate).

## Zapisi mogu imati provjere i 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
}
```

## Zapečaćene klase — kontrolirana nasljeđivanja

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

Zapečaćeni tip eksplicitno navodi svoje dozvoljene podtipove — kontrolirate kompletan skup implementacija, što kompajler provodi. Ovo modelira **zatvorenu hierarhiju** (fiksiran, poznat skup varijanti).

## Zapečaćeni + zapisi + pattern matching = moćno modeliranje

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

Jer su podtipovi zapečaćenog tipa poznati i konačni, kompajler može provjeriti je li `switch` **iscrpan** — uhvaćajući slučajeve koji nedostaju. Kombinirano sa zapisima i pattern matchingom, ovo donosi modeliranje sličnog algebarskim tipovima podataka u Java.

## Zašto je važno

Zapisi i zapečaćene klase su značajne moderne Java značajke koje poboljšavaju izrazitost i sigurnost. **Zapisi** eliminiraju dosadan, podatke sklon na greške stereotipan kod klasa podataka (i jamče ispravne, dosljedne `equals`/`hashCode` — rješavajući tu česti problem) dok forsiraju nepromjenjivost — čineći DTOve, objekte vrijednosti i modeliranje podataka daleko čišćim. **Zapečaćene klase** omogućavaju zatvorene, kontrolirane tipske hijerarhije koje kompajler razumije, što — kombinirano sa zapisima i pattern-matching `switch` — dopušta iscrpno, sigurno rukovanje fiksnim skupom varijanti (algebarski tipovi podataka).

Zajedno čine Java sažetijom, nepromjenjivom-po-zadanom, i sposobnom za sigurnije modeliranje domene.