Records ਅਤੇ sealed classes ਕੀ ਹਨ?

Question

Accepted Answer

**Records** (Java 16+) ਸੰਖੇਪ, ਪਰਿਵਰਤਨਸ਼ੀਲ ਡੇਟਾ ਕੈਰੀਅਰ ਹਨ ਜੋ boilerplate ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ ਬਣਾਉਂਦੇ ਹਨ, ਅਤੇ **sealed classes** (Java 17+) ਹਤਾਸ਼ਾ ਕਰਦੇ ਹਨ ਕਿ ਕਿਹੜੀਆਂ ਕਲਾਸਾਂ ਕਿਸੇ ਕਿਸਮ ਨੂੰ ਵਿਸਤਾਰਤ/ਲਾਗੂ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਦੋਵੇਂ ਆਧੁਨਿਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ ਜੋ Java ਨੂੰ ਹੋਰ ਪ੍ਰਗਟਾਚਾਰੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਅਤੇ ਬਿਹਤਰ ਮਾਡਲਿੰਗ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੀਆਂ ਹਨ।

## Records — ਪਰਿਵਰਤਨਸ਼ੀਲ ਡੇਟਾ, ਜ਼ੀਰੋ 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
```

Ek record ਆਪਣੇ ਕੰਪੋਨੈਂਟਸ ਤੋਂ constructor, accessors, `equals()`, `hashCode()`, ਅਤੇ `toString()` ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ ਬਣਾਉਂਦਾ ਹੈ। ਖੇਤਰ **final** ਹਨ (ਪਰਿਵਰਤਨਸ਼ੀਲ) — records ਸ਼ਫਾਫ, ਪਰਿਵਰਤਨਸ਼ੀਲ ਡੇਟਾ ਕੈਰੀਅਰ (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 — ਨਿਯੰਤ੍ਰਿਤ ਵਿਰਾਸਤ

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

Ek `sealed` ਕਿਸਮ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਆਪਣੇ ਅਨੁਮਤ ਸਬਟਾਈਪਸ ਦੀ ਸੂਚੀ ਬਣਾਉਂਦਾ ਹੈ — ਤੁਸੀਂ ਲਾਗੂਕਰਨ ਦੇ ਪੂਰੇ ਸਮੂਹ ਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਕਰਦੇ ਹੋ, ਜਿਸ ਨੂੰ compiler ਲਾਗੂ ਕਰਦਾ ਹੈ। ਇਹ **ਬੰਦ ਆਪਣੀ ਜਮਾਤ** (ਇੱਕ ਨਿਰਧਾਰਤ, ਜਾਣਿਆ ਸੰਚ) ਮਾਡਲ ਕਰਦਾ ਹੈ।

## Sealed + records + 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
};
```

ਕਿਉਂਕਿ sealed ਕਿਸਮ ਦੇ ਸਬਟਾਈਪਸ ਜਾਣੇ ਜਾਂਦੇ ਅਤੇ ਸੀਮਤ ਹਨ, compiler ਪ੍ਰਮਾਣਿਤ ਕਰ ਸਕਦਾ ਹੈ ਕਿ `switch` **ਵਿਆਪਕ** ਹੈ — ਗੁੰਮ ਕੇਸਾਂ ਨੂੰ ਫੜਨਾ। records ਅਤੇ pattern matching ਦੇ ਨਾਲ ਜੋੜਦਿਆਂ, ਇਹ algebraic-data-type ਸਟਾਈਲ ਮਾਡਲਿੰਗ ਨੂੰ Java ਵਿੱਚ ਲੈ ਆਉਂਦਾ ਹੈ।

## ਇਸ ਦੀ ਕਿਉਂ ਮੁਹਤਾ ਹੈ

Records ਅਤੇ sealed classes ਮਹੱਤਵਪੂਰਨ ਆਧੁਨਿਕ Java ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ ਜੋ ਪ੍ਰਗਟਾਚਾਰ ਅਤੇ ਸੁਰੱਖਿਆ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੀਆਂ ਹਨ। **Records** ਡੇਟਾ ਕਲਾਸਾਂ ਦੇ ਦੁਹਾਵੇ, ਗਲਤੀ ਦਾ ਖਤਰਾ boilerplate ਨੂੰ ਖਤਮ ਕਰਦੇ ਹਨ (ਅਤੇ ਸਹੀ, ਇਕਸਾਰ `equals`/`hashCode` ਦੀ ਗਰੰਟੀ ਦਿੰਦੇ ਹਨ — ਉਸ ਆਮ ਕਮਜ਼ੋਰੀ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ) ਜਦਕਿ ਪਰਿਵਰਤਨਸ਼ੀਲਤਾ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ — DTOs, value objects, ਅਤੇ ਡੇਟਾ ਮਾਡਲਿੰਗ ਨੂੰ ਬਹੁਤ ਸਾਫ ਬਣਾਉਂਦੇ ਹਨ। **Sealed classes** ਬੰਦ, ਨਿਯੰਤ੍ਰਿਤ ਕਿਸਮ ਦੇ ਮੁੱਢ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੇ ਹਨ ਜੋ compiler ਨੂੰ ਸਮਝ ਆਉਂਦਾ ਹੈ, ਜੋ — records ਅਤੇ pattern-matching `switch` ਦੇ ਨਾਲ — ਇੱਕ ਨਿਰਧਾਰਤ ਸੰਚ ਦੇ ਸਮੀਕਰਨ, ਕਿਸਮ-ਸੁਰੱਖਿਤ ਹੈਂਡਲਿੰਗ (algebraic data types) ਦੀ ਆਜ਼ਾਦੀ ਦਿੰਦਾ ਹੈ।

ਇਕੱਠੇ ਉਹ Java ਨੂੰ ਸੰਖੇਪ, ਪਰਿਵਰਤਨਸ਼ੀਲ-ਬਿ-ਮੂਲ, ਅਤੇ ਸੁਰੱਖਿਤ ਡੋਮੇਨ ਮਾਡਲਿੰਗ ਦੇ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ ਜਿਸਨੂੰ ਪੁਰਾਣੇ Java ਨਾਲ ਕਈ ਗੁਣਾ ਜ਼ਿਆਦਾ ਕੋਡ ਦੀ ਲੋੜ ਸੀ।

ਉਨ੍ਹਾਂ ਨੂੰ ਜਾਨਨਾ ਮੌਜੂਦਾ Java ਨਾਲ ਜਾਣ-ਪਛਾਣ ਦਾ ਪ੍ਰਤੀਬਿੰਬ ਕਰਦਾ ਹੈ ਅਤੇ ਸਾਫ, ਹੋਰ ਮਜ਼ਬੂਤ ਡਿਜ਼ਾਇਨਾਂ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਪੁਰਾਣਾ Java ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਬਹੁ ਵਿਆਪਕ ਸੀ।