records और sealed classes क्या हैं?

Question

Accepted Answer

**Records** (Java 16+) संक्षिप्त, immutable data carriers हैं जो boilerplate को auto-generate करते हैं, और **sealed classes** (Java 17+) यह प्रतिबंधित करती हैं कि कौन सी classes किसी type को extend/implement कर सकती हैं। दोनों आधुनिक features हैं जो Java को अधिक अभिव्यंजक बनाते हैं और बेहतर modeling को सक्षम करते हैं।

## Records — immutable data, zero 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 अपने components से constructor, accessors, `equals()`, `hashCode()`, और `toString()` को auto-generate करता है। fields **final** (immutable) होते हैं — records को transparent, immutable data carriers (DTOs, value objects, coordinates) के लिए design किया गया है।

## Records में validation और 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

```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` type स्पष्ट रूप से अपने permitted subtypes को सूचीबद्ध करता है — आप implementations के पूरे set को नियंत्रित करते हैं, जिसे compiler लागू करता है। यह एक **closed hierarchy** (variants का एक निश्चित, ज्ञात set) को model करता है।

## Sealed + records + pattern matching = शक्तिशाली 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
};
```

क्योंकि एक sealed type के subtypes ज्ञात और सीमित हैं, compiler सत्यापित कर सकता है कि एक `switch` **exhaustive** है — छूटे हुए cases को पकड़ता है। records और pattern matching के साथ मिलकर, यह Java में algebraic-data-type शैली की modeling लाता है।

## यह क्यों महत्वपूर्ण है

Records और sealed classes महत्वपूर्ण आधुनिक Java features हैं जो अभिव्यंजकता और सुरक्षा में सुधार करते हैं। **Records** data classes के उबाऊ, error-prone boilerplate को समाप्त करते हैं (और सही, consistent `equals`/`hashCode` की गारंटी देते हैं — उस आम pitfall को हल करते हुए) जबकि immutability को लागू करते हैं — जिससे DTOs, value objects, और data modeling कहीं अधिक साफ-सुथरी हो जाती है। **Sealed classes** बंद, नियंत्रित type hierarchies को सक्षम करती हैं जिन्हें compiler समझता है, जो — records और pattern-matching `switch` के साथ मिलकर — variants के एक निश्चित set की exhaustive, type-safe handling की अनुमति देती हैं (algebraic data types)।

साथ में वे Java को अधिक संक्षिप्त, immutable-by-default, और सुरक्षित domain modeling में सक्षम बनाते हैं।

इन्हें जानना current Java में प्रवाह को दर्शाता है और साफ-सुथरे, अधिक robust designs को सक्षम बनाता है जिन्हें प्राप्त करने के लिए पुराने Java को कहीं अधिक code की आवश्यकता होती थी।