Apa wae jinis-jinis nested class ing Java?

Question

Accepted Answer

A **nested class** minangka class sing didefinisikake ing dalam class liyane. Java nduweni papat jinis — **static nested**, **inner (non-static)**, **local**, lan **anonymous** — saben-saben nduweni akses beda-beda marang enclosing class lan use case beda-beda.

## 1. Static nested class — independen saka 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 berperilaku kaya class tingkat puncak nanging dibungkus ing dalam class luar. Iku **ora** nyimpan referensi menyang instance luar — digunakake kanggo ngelompokake helper (cth. `Builder`, `Node` ing struktur data).

## 2. Inner (non-static) class — kaitan karo 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 nyimpan referensi implicit menyang instance enclosing-ne, supaya bisa ngakses field instance obyek luar. (Hati-hati: referensi iki bisa nyebabake **memory leaks** yen instance inner ngluwihi instance luar.)

## 3. Local class — didefinisikake ing dalam method

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

Jarang digunakake; dipengerteni menyang method.

## 4. Anonymous class — implementasi sekali-pakai, tanpa jeneng

```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 minangka implementasi sekali-jalan saka interface utawa class, didefinisikake lan diinstansiasi saengga-engga — historis umum kanggo event handler lan callback. Java modern asring ngganti iki nganggo **lambda** yen target minangka functional interface:

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

## Dene penting

Nested class minangka alat sing berguna kanggo **ngelompokake class kanthi logis** sing mung digunakake ing konteks siji, nambah encapsulation lan readability.

Paham jinis-jinis — utamane **static-vs-inner distinction** (static = independen, inner = nyimpan referensi enclosing-instance) — penting kanggo desain lan mbantesi bug: referensi outer implicit inner class bisa nyebabake memory leaks, lan milih static yen ora butuh instance luar minangka standar sing luwih resik.

Anonymous class minangka cara klasik nyedhiyakake inline implementation (event handler, comparator), lan weruh yen liyane asring diganti lambdas kanggo functional interface ngrefleksikake modern Java fluency.

Iki mucul ing seluruh standard library (cth. `Map.Entry` minangka nested interface, builder minangka static nested class), nggawe iku praktis, pengetahuan sing asring diklabu.