Wane ne nau'ikan ajiya-jiya a Java?

Question

Accepted Answer

A **nested class** shine ajiya da aka bayyana a cikin wata ajiya. Java yana da nau'i hudu — **static nested**, **inner (non-static)**, **local**, da **anonymous** — kowannensu yana da damar daban-daban zuwa ajiya ta waje da sassa daban-daban na amfani.

## 1. Static nested class — mai cin gashin kai daga abin da aka samu

```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 yana aiki kamar ajiya na babbar matakin amma ana amfani da shi a cikin wata. Ba shi **ba** rike da hannu zuwa wani abin da aka samu na waje — ana amfani da shi don haduwa da masu taimakawa (misali a `Builder`, `Node` a cikin tsarin bayani).

## 2. Inner (non-static) class — da alaƙa zuwa abin da aka samu

```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 yana rike da himmiyar hannu zuwa ajiya ta waje, saboda ya kamata ya iya shiga filayen ajiya ta waje. (Imta: wannan hannu na iya haifar da **ɓatattun ɗabi'u** idan ajiya ta ciki ta fi tsofon ta waje).

## 3. Local class — da aka bayyana a cikin wata hanya

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

Ba a amfani da shi sosai; an saita shi zuwa hanya.

## 4. Anonymous class — aiki mai kaye-kaye, babu suna

```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 shine aiki mai kaye-kaye na sadarwa ko ajiya, da aka bayyana da aka saita lokaci gida — a jiya ana amfani da shi da yawa don gudun abubuwan fada da sake kiran abubuwa. Java na yanzu yakan maye gurbin wadannan da **lambdas** lokacin da burin takaita shine sadarwa mai aiki:

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

## Me ya sa hakan ya matuƙa

Nested classes shine kayan aiki mai amfani don **tara jituwa a hankali** ajiya da aka amfani kawai a waje gida, yana kara ɗakatar da bayani da karuwa na carke.

Samuwar nau'ikan — musamman bambancin **static-vs-inner** (static = mai cin gashin kai, inner = yana rike da hannu zuwa ajiya ta waje) — yana da mahimmanci don tsarin kwana-da-kwana da girmamawa: hanyoyin ajiya na cikin su ba tiya ba suke rikewa na sakamakon ajiya na waje na iya haifar da ɓatattun ɗabi'u, da zabian static lokacin da ba ka buƙata ajiya ta waje shine maƙon tsafi.

Anonymous classes sun kasance hanya ta gida don samar da abubuwa a ciki (gudun abubuwan fada, masu kwatanta), da sanin sun fi saboda lambdas don sadarwa mai aiki yana nuna carke na Java na zamani.

Wadannan suna bayyana a duk waje na kitabin ɗin (misali `Map.Entry` shine sadarwa ta ajiya, masu gina su static nested classes), yana sanya su aiki, ilimin da ake kawai gida.