Java मध्ये nested classes कोणत्या प्रकारचे असतात?

Question

Accepted Answer

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

A `static` nested class हा top-level class सारखे वर्तन करतो परंतु outer class मध्ये namespace केलेला असतो. हा outer instance ला reference **ठेवत नाही** — हा helpers grouping करण्यासाठी वापरला जातो (उदा. `Builder`, data structure मध्ये `Node`).

## 2. Inner (non-static) class — instance ला tied

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

An **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 हा **logically grouping** करण्यासाठी एक उपयुक्त साधन आहे — classes ज्या फक्त एक context मध्ये वापरल्या जातात, encapsulation आणि readability वाढवतात.

प्रकार समजणे — विशेषतः **static-vs-inner distinction** (static = स्वतंत्र, inner = enclosing-instance reference ठेवतो) — design आणि bugs टाळण्या दोन्हीसाठी महत्त्वाचे आहे: inner classes चा implicit outer reference memory leaks कारण बनू शकतो, आणि static निवडणे जेव्हा तुम्हाला outer instance आवश्यक नाही हा cleaner default आहे.

Anonymous classes हा inline implementations प्रदान करण्याचा classical मार्ग होता (event handlers, comparators), आणि हे जाणून घेणे की ते functional interfaces साठी lambdas ने बदलले गेले हे आधुनिक Java fluency दर्शवते.

हे standard library मध्ये सर्वत्र दिसतात (उदा. `Map.Entry` हा nested interface आहे, builders static nested classes आहेत), जे त्यांना practical, frequently-encountered knowledge बनवते.