records மற்றும் sealed classes என்றால் என்ன?

Question

Accepted Answer

**Records** (Java 16+) என்பவை சுருக்கமான, immutable data carriers ஆகும், அவை boilerplate-ஐ auto-generate செய்கின்றன, மேலும் **sealed classes** (Java 17+) ஒரு type-ஐ எந்த classes விரிவாக்க/implement செய்யலாம் என்பதைக் கட்டுப்படுத்துகின்றன. இரண்டும் Java-ஐ மேலும் வெளிப்படையாக்கி சிறந்த modeling-ஐ சாத்தியமாக்கும் நவீன features ஆகும்.

## 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 வெளிப்படையான, immutable data carriers-க்காக (DTOs, value objects, coordinates) வடிவமைக்கப்பட்டுள்ளன.

## 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 அதன் அனுமதிக்கப்பட்ட subtypes-ஐ வெளிப்படையாக பட்டியலிடுகிறது — implementations-இன் முழுமையான தொகுப்பை நீங்கள் கட்டுப்படுத்துகிறீர்கள், அதை compiler அமல்படுத்துகிறது. இது ஒரு **closed hierarchy**-ஐ (ஒரு நிலையான, அறியப்பட்ட variants தொகுப்பு) மாதிரியாக்குகிறது.

## 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 அறியப்பட்டவையும் வரையறுக்கப்பட்டவையும் என்பதால், ஒரு `switch` **exhaustive** என்பதை compiler சரிபார்க்க முடியும் — விடுபட்ட cases-ஐ பிடிக்கிறது. records மற்றும் pattern matching-உடன் இணைந்து, இது algebraic-data-type பாணி modeling-ஐ Java-வுக்கு கொண்டுவருகிறது.

## இது ஏன் முக்கியம்

Records மற்றும் sealed classes வெளிப்பாட்டையும் பாதுகாப்பையும் மேம்படுத்தும் குறிப்பிடத்தக்க நவீன Java features ஆகும். **Records** data classes-இன் சலிப்பான, பிழைக்கு வாய்ப்புள்ள boilerplate-ஐ அகற்றுகின்றன (மற்றும் சரியான, நிலையான `equals`/`hashCode`-ஐ உறுதி செய்கின்றன — அந்த பொதுவான ஆபத்தை தீர்க்கின்றன) அதே சமயம் immutability-ஐ அமல்படுத்துகின்றன — DTOs, value objects, மற்றும் data modeling-ஐ மிகவும் சுத்தமாக்குகின்றன. **Sealed classes** compiler புரிந்துகொள்ளும் closed, கட்டுப்படுத்தப்பட்ட type hierarchies-ஐ சாத்தியமாக்குகின்றன, இது — records மற்றும் pattern-matching `switch`-உடன் இணைந்து — நிலையான variants தொகுப்பின் exhaustive, type-safe கையாளுதலை அனுமதிக்கிறது (algebraic data types).

ஒன்றாக அவை Java-ஐ மேலும் சுருக்கமாகவும், immutable-by-default ஆகவும், பாதுகாப்பான domain modeling-க்கு திறன்மிக்கதாகவும் ஆக்குகின்றன.

அவற்றை அறிவது தற்போதைய Java-வுடன் சரளத்தை பிரதிபலிக்கிறது மற்றும் பழைய Java-வுக்கு அதிக code தேவைப்பட்ட சுத்தமான, மிகவும் வலுவான designs-ஐ சாத்தியமாக்குகிறது.