Java मा nested classes का किसिम छन्?

Question

Accepted Answer

एक **nested class** भनेको अर्को class भित्र परिभाषित गरिएको class हो। Java मा चार किसिम छन् — **static nested**, **inner (non-static)**, **local**, र **anonymous** — प्रत्येकको enclosing class को लागि फरक पहुँच र फरक 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 जस्तै व्यवहार गर्छ तर बाहिरको एक भित्र namespace भएको छ। यो बाहिरको 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 राख्छ, त्यसैले यो बाहिरको object को instance fields लाई पहुँच गर्न सक्छ। (सावधानी: यो reference **memory leaks** का कारण हुन सक्छ यदि inner instance बाहिरको भन्दा लामो समय सम्म रहन्छ।)

## 3. Local class — एक method भित्र परिभाषित

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

विरलै प्रयोग गरिन्छ; method को लागि scoped।

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

एक **anonymous** class एक interface वा class को एकमुष्ट कार्यान्वयन हो, एक साथ परिभाषित र 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 लाई **तार्किक रूपमा समूहबद्ध** गर्नको लागि एक उपयोगी उपकरण छन् जो केवल एक context मा प्रयोग गरिन्छन्, encapsulation र readability बढाउँछन्।

किसिमहरू बुझ्न — विशेष गरी **static-vs-inner distinction** (static = स्वतन्त्र, inner = enclosing-instance reference राख्छ) — दुवै डिजाइन र bugs बचाउन को लागि महत्त्वपूर्ण छ: inner classes को implicit outer reference memory leaks का कारण हुन सक्छ, र जब तपाइलाई बाहिरको instance को आवश्यकता छैन तब static चयन गर्न पनि छ।

Anonymous classes inline implementations (event handlers, comparators) प्रदान गर्ने को लागि क्लासिक तरिका थे, र जान्न कि यिनलाई मुख्य रूपमा lambdas द्वारा functional interfaces को लागि प्रतिस्थापन गरिएको छ आधुनिक Java fluency को प्रतिबिम्ब हो।

यिनहरू standard library मा सर्वत्र देखिन्छन् (उदाहरणका लागि `Map.Entry` एक nested interface हो, builders static nested classes हुन्), यिनलाई व्यावहारिक, बारम्बार-सामना गरिएको ज्ञान बनाइन्छ।