જાવામાં nested classes ના કયા પ્રકાર છે?

Question

Accepted Answer

A **nested class** એ એક વર્ગ છે જે અન્ય વર્ગમાં વ્યાખ્યાયિત કરવામાં આવે છે. જાવામાં ચાર પ્રકાર છે — **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 વર્ગમાં 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
```

A non-static **inner** class તેના enclosing instance પર implicit reference રાખે છે, તેથી તે outer object ના instance fields ને access કરી શકે છે. (સાવધાનીઃ આ 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 — એક-વાર 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 માટે સામાન્ય હતું. આધુનિક જાવા ઘણીવાર આને **lambdas** સાથે બદલે છે જ્યારે target એ functional interface હોય:

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

## તે શા માટે મહત્વપૂર્ણ છે

Nested classes એ **તાર્કિક રીતે વર્ગોને સમૂહ બનાવવા** નું એક ઉપયોગી સાધન છે જે માત્ર એક context માં વપરાય છે, encapsulation અને readability વધારે છે.

પ્રકારોને સમજવું — ખાસ કરીને **static-vs-inner તફાવત** (static = independent, inner = enclosing-instance reference રાખે છે) — ડિજાઇન અને bugs ટાળવા બંને માટે મહત્વપૂર્ણ છે: inner classes ના implicit outer reference memory leaks પ્રમાણિત કરી શકે છે, અને જ્યારે તમને outer instance ની જરૂર નથી ત્યારે static પસંદ કરવું તે સ્વચ્છ default છે.

Anonymous classes inline implementations (event handlers, comparators) આપવાનો ઐતિહાસિક રીતો હતો, અને તે જાણવું કે તેઓ largely functional interfaces માટે lambdas દ્વારા બદલાયેલ છે તે આધુનિક જાવા fluency પ્રતિબિંબિત કરે છે.

તે standard library (દા.ત., `Map.Entry` એક nested interface છે, builders static nested classes છે) માં બધે દેખાય છે, તેમને practical, frequently-encountered knowledge બનાવે છે.