రికార్డ్‌లు మరియు సీల్‌డ్ క్లాస్‌లు అంటే ఏమిటి?

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

ఒక record దాని components నుండి constructor, accessors, `equals()`, `hashCode()`, మరియు `toString()` ను స్వయంచాలకంగా ఉత్పన్నం చేస్తుంది. ఫీల్డ్‌లు **final** (మార్పులేనివి) — records స్పష్టమైన, మార్పులేని డేటా క్యారియర్‌ల కోసం (DTOs, value objects, coordinates) ను ఉద్దేశ్యంగా కృష్టం చేయబడ్డాయి.

## రికార్డ్‌లు 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
}
```

## సీల్‌డ్ క్లాస్‌లు — నియంత్రిత వారసత్వం

```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` రకం దాని అనుమతించిన subtypes ని స్పష్టంగా జాబితా చేస్తుంది — మీరు అమలుల సంపూర్ణ సమితిని నియంత్రిస్తారు, కంపైలర్ దీనిని ప్రవర్తిస్తుంది. ఇది **closed hierarchy** ను మోడల్ చేస్తుంది (ఒక నిర్ణీత, తెలిసిన వేరియంట్‌ల సమితి).

## సీల్‌డ్ + రికార్డ్‌లు + 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
};
```

ఎందుకంటే సీల్‌డ్ రకం యొక్క subtypes తెలిసినవి మరియు పరిమితమైనవి, కంపైలర్ `switch` ఒక **exhaustive** ఆ — తప్పిన కేసులను పట్టుకోవడం. records మరియు pattern matching కలిసి, ఇది Java కు algebraic-data-type శైలి మాడలింగ్‌ను తీసుకువస్తుంది.

## ఇది ఎందుకు ముఖ్యమైనది

রికార్డ్‌లు మరియు సీల్‌డ్ క్లాస్‌లు ముఖ్యమైన ఆధునిక Java ఫీచర్‌లు, ఇవి వ్యక్తీకరణ మరియు సురక్షను మెరుగుపరుస్తాయి. **రికార్డ్‌లు** డేటా క్లాస్‌ల యొక్క శ్రమతరమైన, లోపానికి గురయ్యే boilerplate ను తొలగిస్తాయి (మరియు సరైన, స్థిరమైన `equals`/`hashCode` ను నిర్ధారిస్తాయి — ఆ సాధారణ ఆపాదన సమస్యను పరిష్కరిస్తాయి) అయితే మార్పులేనితను ఎనేబుల్ చేస్తాయి — DTOs, value objects, మరియు డేటా మాడలింగ్‌ను చాలా శుభ్రం చేస్తాయి. **సీల్‌డ్ క్లాస్‌లు** closed, నియంత్రిత రకం systems ను ఎనేబుల్ చేస్తాయి, ఇవి కంపైలర్ అర్థం చేసుకుంటుంది, ఇది — records మరియు pattern-matching `switch` కలిసి — నిర్ణీత వేరియంట్‌ల సమితి (algebraic data types) కు exhaustive, type-safe హ్యాండలింగ్‌ను అనుమతిస్తుంది.

ఇవి కలిసి Java ను మరింత సంక్షిప్త, మార్పులేనివి-by-default, మరియు సురక్షితమైన domain modeling యొక్క సామర్థ్యవంతమైనవిగా చేస్తాయి.

వాటిని తెలుసుకోవడం ప్రస్తుత Java కు నిష్ణాతను ప్రతిబింబిస్తుంది మరియు శుభ్రమైన, బలమైన డిజైన్‌ల ను ఎనేబుల్ చేస్తుంది, పాత Java ఇవన్ని చేయడానికి చాలా కోడ్‌ను అవసరం చేసింది.