რა არის ჩანაწერები (records) და დალუმიერი კლასები (sealed classes)?

Question

Accepted Answer

**ჩანაწერები** (Java 16+) არის კონციზური, უცვლელი მონაცემთა მატარებელი, რომელიც ავტომატურად აგენერირებს boilerplate კოდს, ხოლო **დალუმიერი კლასები** (Java 17+) შეზღუდავს რომელი კლასები შეიძლება გააფართოვოს/გამოიყენოს ტიპი. ორივე არის თანამედროვე ფიჩარი, რომელიც Java-ს უფრო გამოხატულ ხდის და უკეთეს მოდელირებას უზრუნველყოფს.

## ჩანაწერები — უცვლელი მონაცემები, ნულოვანი 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
```

ჩანაწერი ავტომატურად აგენერირებს კონსტრუქტორს, წვდომის მეთოდებს, `equals()`-ს, `hashCode()`-ს და `toString()`-ს მისი კომპონენტებიდან. ველები არის **final** (უცვლელი) — ჩანაწერები შექმნილია გამჭვირვალე, უცვლელი მონაცემთა მატარებლებისთვის (DTOs, მნიშვნელობის ობიექტები, კოორდინატები).

## ჩანაწერებს შეიძლება ჰქონდეს ვალიდაცია და მეთოდები

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

## დალუმიერი კლასები — კონტროლირებული მემკვიდრეობა

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

`sealed` ტიპი ხელმისაწვდომლად აჩქარებს მის ნებართვებულ ქვეტიპებს — თქვენ აკონტროლებთ რეალიზაციების სრულ ნაკრებს, რომელსაც კომპილატორი აკმაყოფილებს. ეს მოდელირებს **დახურულ იერარქიას** (ფიქსირებული, ცნობილი ვარიანტების ნაკრები).

## დალუმიერი + ჩანაწერები + pattern matching = მძლავრი მოდელირება

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

ორი მიზეზით, რომ დალუმიერი ტიპის ქვეტიპები ცნობილი და სასრულია, კომპილატორი შეიძლება გადამოწმოს, რომ `switch` არის **ამომწურავი** — გამომტოვებული შემთხვევების ჩაჭერა. ჩანაწერებისა და pattern matching-ის ერთად გამოყენებით, ეს ალგებრული მონაცემთა ტიპი მოდელირება Java-ზე მოდის.

## რატომ არის ეს მნიშვნელოვანი

ჩანაწერები და დალუმიერი კლასები მნიშვნელოვანი თანამედროვე Java ფიჩარია, რომელიც აუმჯობესებს გამოხატულობას და უსაფრთხოებას. **ჩანაწერები** აღმოფხვრის მოიძულებელ, შეცდომაზე მგრძნობიარე boilerplate კოდს მონაცემთა კლასებისთვის (და გარანტირებს სწორ, თანმიმდევრულ `equals`/`hashCode`-ს — მოაგვარებს იმ ხშირ პრობლემას) ხოლო აკმაყოფილებს უცვლელობას — მონაცემთა სტრუქტურების, მნიშვნელობის ობიექტების და მონაცემთა მოდელირების გაკეთება ბევრად უფრო სუფთა. **დალუმიერი კლასები** უზრუნველყოფენ დახურულ, კონტროლირებულ ტიპის იერარქიებს, რომელიც კომპილატორი მესმის, რაც — ჩანაწერებისა და pattern-matching `switch`-ის ერთად გამოყენებით — იძლევა ამომწურავ, ტიპისთვის უსაფრთხო დამუშავებას ფიქსირებული ვარიანტების ნაკრების (ალგებრული მონაცემთა ტიპი).

ისინი ერთად Java-ს უფრო კონციზურ, უცვლელობით ნაგულისხმევ ხდიან და უსაფრთხოვი დომენის მოდელირებაში უნარჩუნელი, რომელიც ძველი Java-ს მნიშვნელოვნად მეტი კოდი მოითხოვდა.