Java ਵਿੱਚ nested classes ਦੀਆਂ ਕਿਸਮਾਂ ਕੀ ਹਨ?

Question

Accepted Answer

A **nested class** ਇੱਕ class ਹੈ ਜੋ ਕਿਸੇ ਹੋਰ class ਦੇ ਅੰਦਰ ਪਰਿਭਾਸ਼ਿਤ ਹੁੰਦੀ ਹੈ। Java ਵਿੱਚ ਚਾਰ ਕਿਸਮਾਂ ਹਨ — **static nested**, **inner (non-static)**, **local**, ਅਤੇ **anonymous** — ਹਰ ਇੱਕ ਦੇ ਵੱਖ-ਵੱਖ enclosing class ਤੱਕ ਪਹੁੰਚ ਅਤੇ ਵੱਖ-ਵੱਖ ਉਪਯੋਗ ਹਨ।

## 1. Static nested class — instance ਤੋਂ ਸੁਤੰਤਰ

```java
public class Outer {
    private static int data = 10;

static class Nested {            // static → no reference to an Outer INSTANCE
        void show() {
            System.out.println(data);  // can access static members of Outer only
        }
    }
}
Outer.Nested n = new Outer.Nested();   // created without an Outer instance
```

A `static` nested class ਇੱਕ top-level class ਵਾਂਗ ਵਿਵਹਾਰ ਕਰਦੀ ਹੈ ਪਰ outer ਇੱਕ ਦੇ ਅੰਦਰ namespace ਹੁੰਦੀ ਹੈ। ਇਹ outer instance ਦਾ ਕੋਈ reference **ਨਹੀਂ** ਰੱਖਦੀ — helper classes ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ (ਜਿਵੇਂ `Builder`, data structure ਵਿੱਚ `Node`)।

## 2. Inner (non-static) class — instance ਨਾਲ ਬੰਧੇ ਹੋਏ

```java
public class Outer {
    private int value = 5;

class Inner {                     // non-static → has an implicit reference to Outer
        void show() {
            System.out.println(value); // can access Outer's INSTANCE members (even private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // needs an Outer instance to create
```

A non-static **inner** class ਆਪਣੀ enclosing instance ਦਾ implicit reference ਰੱਖਦੀ ਹੈ, ਇਸ ਲਈ ਇਹ outer object ਦੇ instance fields ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ। (ਸਾਵਧਾਨੀ: ਇਹ reference **memory leaks** ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ ਜੇਕਰ inner instance outer ਨੂੰ outlive ਕਰੇ।)

## 3. Local class — method ਦੇ ਅੰਦਰ ਪਰਿਭਾਸ਼ਿਤ

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

Shayad ਹੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ; method ਦੇ scope ਵਿੱਚ।

## 4. Anonymous class — ਇੱਕ-ਵਾਰਗੀ ਲਾਗੂ ਕਰਨਾ, ਕੋਈ ਨਾਂ ਨਹੀਂ

```java
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

Runnable task = new Runnable() {
    public void run() { System.out.println("running"); }
};
```

An **anonymous** class ਇੱਕ interface ਜਾਂ class ਦਾ ਇੱਕ one-shot ਲਾਗੂ ਕਰਨਾ ਹੈ, ਇੱਕਾ ਉੱਪਰ ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ instantiate ਕੀਤਾ ਜਾਂਦਾ ਹੈ — ਐਤਿਹਾਸਿਕ ਤੌਰ 'ਤੇ event handlers ਅਤੇ callbacks ਲਈ ਆਮ। ਆਧੁਨਿਕ Java ਅਕਸਰ ਇਹਨਾਂ ਨੂੰ **lambdas** ਨਾਲ ਬਦਲਦਾ ਹੈ ਜਦੋਂ target ਇੱਕ functional interface ਹੋ:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

Nested classes ਇਹ ਇੱਕ ਸੁਪਯੋਗੀ ਟੂਲ ਹੈ classes ਨੂੰ **logically group ਕਰਨ** ਲਈ ਜੋ ਸਿਰਫ ਇੱਕ context ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, encapsulation ਅਤੇ readability ਨੂੰ ਵਧਾਉਂਦੇ ਹੋਏ।

ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ — ਖਾਸ ਕਰਕੇ **static-vs-inner ਅੰਤਰ** (static = ਸੁਤੰਤਰ, inner = enclosing-instance reference ਰੱਖਦਾ ਹੈ) — ਡਿਜ਼ਾਇਨ ਅਤੇ ਬੱਗ ਤੋਂ ਬਚਣ ਦੋਨਾਂ ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ: inner classes ਦਾ implicit outer reference memory leaks ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ, ਅਤੇ static ਚੁਣਨਾ ਜਦੋਂ ਤੁਹਾਨੂੰ outer instance ਦੀ ਲੋੜ ਨਹੀਂ ਸਮਝਦਾਰੀ ਭਰੀ default ਹੈ।

Anonymous classes ਸਾਹਤ ਵਿੱਚ inline implementations ਪ੍ਰਦਾਨ ਕਰਨ ਦਾ classical ਤਰੀਕਾ ਸਨ (event handlers, comparators), ਅਤੇ ਜਾਣਨਾ ਕਿ ਉਹ ਵਧਾਉਂਤੇ ਹੋਏ lambdas ਦੁਆਰਾ functional interfaces ਲਈ ਬਦਲੇ ਗਏ ਹਨ, ਆਧੁਨਿਕ Java fluency ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਤ ਕਰਦਾ ਹੈ।

ਇਹ ਪੂਰੇ standard library ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ `Map.Entry` ਇੱਕ nested interface ਹੈ, builders static nested classes ਹਨ), ਜੋ ਇਹਨਾਂ ਨੂੰ ਵਿਵਹਾਰਕ, ਅਕਸਰ-ਆਏ-ਜਾਣ-ਵਾਲੇ ਗਿਆਨ ਬਣਾਉਂਦੇ ਹਨ।