Java में nested classes के कौन से प्रकार हैं?

Question

Accepted Answer

एक **nested class** एक ऐसी class है जो किसी अन्य class के अंदर परिभाषित की जाती है। Java में चार प्रकार हैं — **static nested**, **inner (non-static)**, **local**, और **anonymous** — प्रत्येक के पास enclosing class तक अलग-अलग access और अलग-अलग use cases हैं।

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

एक `static` nested class एक top-level class की तरह व्यवहार करती है लेकिन outer class के अंदर namespaced होती है। यह किसी outer instance का reference **नहीं** रखती — helpers को समूहित करने के लिए उपयोग की जाती है (जैसे एक `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
```

एक non-static **inner** class अपने enclosing instance का एक implicit reference रखती है, इसलिए यह outer object के instance fields को access कर सकती है। (सावधानी: यदि inner instance outer से अधिक समय तक जीवित रहता है तो यह reference **memory leaks** का कारण बन सकता है।)

## 3. Local class — एक method के अंदर परिभाषित

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

शायद ही कभी उपयोग की जाती है; method तक scoped।

## 4. Anonymous class — एक बार का implementation, कोई नाम नहीं

```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"); }
};
```

एक **anonymous** class किसी interface या class का एक बार का implementation है, जिसे एक साथ परिभाषित और 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 को **तार्किक रूप से समूहित करने** के लिए एक उपयोगी उपकरण हैं जो केवल एक संदर्भ में उपयोग की जाती हैं, encapsulation और पठनीयता बढ़ाते हुए।

प्रकारों को समझना — विशेष रूप से **static-बनाम-inner अंतर** (static = स्वतंत्र, inner = एक enclosing-instance reference रखती है) — design और bugs से बचने दोनों के लिए मायने रखता है: inner classes का implicit outer reference memory leaks का कारण बन सकता है, और जब आपको outer instance की आवश्यकता न हो तो static चुनना साफ-सुथरा default है।

Anonymous classes inline implementations (event handlers, comparators) प्रदान करने का classic तरीका थे, और यह जानना कि functional interfaces के लिए वे काफी हद तक lambdas द्वारा प्रतिस्थापित हो गई हैं, आधुनिक Java प्रवाह को दर्शाता है।

ये standard library में सर्वत्र दिखाई देती हैं (जैसे `Map.Entry` एक nested interface है, builders static nested classes हैं), जो उन्हें व्यावहारिक, अक्सर सामना किया जाने वाला ज्ञान बनाती हैं।