Java లో nested classes ఏ రకాలు ఉన్నాయి?

Question

Accepted Answer

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

A `static` nested class top-level class వలె ఆచరణ చేస్తుంది కానీ outer లో namespace చేయబడింది. ఇది outer instance కు reference **కలిగి లేదు** — helpers (ఉదాహరణకు `Builder`, `Node` data structure లో) సమూహపరచడానికి ఉపయోగించబడుతుంది.

## 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 కంటే ఎక్కువ కాలం ఉండితే.)

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

An **anonymous** class ఒక interface లేదా class యొక్క one-shot అమలు, ఒకేసారి నిర్వచించిన మరియు instantiated — చారిత్రికంగా 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 వివక్ష** (static = స్వతంత్రం, inner = enclosing-instance reference కలిగి ఉంటుంది) — డిజైన మరియు bugs నివారించడానికి రెండింటికీ ముఖ్యమైనది: inner classes' implicit outer reference memory leaks కు కారణం కావచ్చు, మరియు choosing static మీకు outer instance అవసరం లేనిపుడు cleaner default.

Anonymous classes inline implementations (event handlers, comparators) ఇవ్వడానికి classical way, మరియు knowing వారు largely superseded lambdas ద్వారా functional interfaces కోసం reflects ఆధునిక Java fluency.

ఈవిధి మొత్తం library లో కనిపిస్తుంది (ఉదాహరణకు `Map.Entry` nested interface, builders static nested classes), వాటిని practical, frequently-encountered knowledge చేస్తుంది.