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 போல் செயல்படுகிறது ஆனால் outer one-க்குள் namespace செய்யப்பட்டுள்ளது. இது ஒரு 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-ஐ அணுக முடியும். (கவனம்: 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-க்கு scope செய்யப்பட்டுள்ளது.

## 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 target ஒரு functional interface ஆக இருக்கும்போது இவற்றை அடிக்கடி **lambdas**-ஆல் மாற்றுகிறது:

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

## இது ஏன் முக்கியம்

Nested classes ஒரே சூழலில் மட்டுமே பயன்படுத்தப்படும் classes-ஐ **தர்க்கரீதியாக குழுவாக்க** ஒரு பயனுள்ள கருவியாகும், encapsulation-ஐயும் வாசிக்கும் தன்மையையும் அதிகரிக்கிறது.

வகைகளைப் புரிந்துகொள்வது — குறிப்பாக **static-vs-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), மேலும் functional interfaces-க்கு அவை பெரும்பாலும் lambdas-ஆல் மாற்றப்பட்டுள்ளன என்பதை அறிவது நவீன Java சரளத்தை பிரதிபலிக்கிறது.

இவை standard library முழுவதும் தோன்றுகின்றன (எ.கா. `Map.Entry` ஒரு nested interface, builders static nested classes ஆகும்), அவற்றை நடைமுறை, அடிக்கடி-சந்திக்கப்படும் அறிவாக ஆக்குகின்றன.