რა სახის nested class–ები არსებობს Java–ში?

Question

Accepted Answer

**nested class** არის კლასი, რომელიც განსაზღვრულია სხვა კლასის შიგნით. Java–ში არსებობს ოთხი სახე — **static nested**, **inner (non-static)**, **local** და **anonymous** — თითოეულს აქვს განსხვავებული წვდომა enclosed class–ზე და განსხვავებული გამოყენების შემთხვევები.

## 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–ოვანია outer კლასის შიგნით. ის **არ** ინარჩუნებს გარე instance–ის reference–ს — გამოიყენება helper–ების დაჯგუფებისთვის (მაგალითად, `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
```

non-static **inner** class ინარჩუნებს implicit reference–ს თავის enclosed instance–ზე, ამიტომ შეუძლია outer object–ის instance field–ებზე წვდომა. (ფრთხილად: ეს reference შეიძლება გამოიწვიოს **memory leak**–ი, თუ inner instance–ი გადაჯდება outer–ზე).

## 3. Local class — განსაზღვრული method–ის შიგნით

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

드물ად გამოიყენება; scoped method–ით.

## 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, განსაზღვრული და instantiated–ი ერთდროულად — ისტორიულად გავრცელებული event handler–ებისა და callback–ებისთვის. თანამედროვე Java–ში ხშირად ამათ ჩაანაცვლებს **lambda**, როდესაც target არის functional interface:

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

## რატომ არის მნიშვნელოვანი

Nested class–ები არის სასარგებლო ინსტრუმენტი **ლოგიკურად დაჯგუფებისთვის** კლასებისა, რომელიც გამოიყენება მხოლოდ ერთ context–ში, increasing encapsulation და readability–ს.

სახეების გაგება — განსაკუთრებით **static-vs-inner distinction** (static = დამოუკიდებელი, inner = ინარჩუნებს enclosed-instance reference–ს) — მნიშვნელოვანია დიზაინისთვის და bug–ების თავიდან აცილებისთვის: inner class–ების implicit outer reference შეიძლება გამოიწვიოს memory leak–ი, და static–ის არჩევა, როდესაც არ გჭირდებათ outer instance, არის უფრო깔끔한default.

Anonymous class–ები იყო კლასიკური გზა inline implementation–ის უზრუნველყოფისთვის (event handler–ები, comparator–ები), და ის, რომ ისინი ძირითადად functional interface–ებისთვის lambda–ზე განაცვლეს, ასახავს თანამედროვე Java fluency–ს.

ისინი მოცემული არიან მთელი standard library–ში (მაგალითად, `Map.Entry` არის nested interface, builder–ები არიან static nested class–ები), რაც მათ საქმიანი, ხშირად შეწყვილებული ცოდნას ხდის.