Apakah jenis-jenis nested classes dalam Java?

Question

IT Interview Practice · Accepted Answer

Satu **nested class** ialah kelas yang ditakrifkan di dalam kelas lain. Java mempunyai empat jenis — **static nested**, **inner (non-static)**, **local**, dan **anonymous** — masing-masing dengan akses yang berbeza kepada kelas yang melingkungi dan kes penggunaan yang berbeza.

## 1. Static nested class — bebas daripada satu 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
```

Satu `static` nested class berkelakuan seperti kelas peringkat atas tetapi dinamakan ruang di dalam kelas luar. Ia **tidak** memegang rujukan kepada instance luar — digunakan untuk mengumpulkan pembantu (cth. satu `Builder`, `Node` dalam struktur data).

## 2. Inner (non-static) class — terikat kepada satu 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
```

Satu **inner** class non-static memegang rujukan tersirat kepada instance yang melingkunginya, jadi ia boleh mengakses medan instance objek luar. (Awas: rujukan ini boleh menyebabkan **kebocoran memori** jika instance inner hidup lebih lama daripada instance luar.)

## 3. Local class — ditakrifkan di dalam satu kaedah

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

Jarang digunakan; diskop kepada kaedah tersebut.

## 4. Anonymous class — pelaksanaan sekali-guna, tiada nama

```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"); }
};
```

Satu **anonymous** class ialah pelaksanaan sekali-guna bagi satu interface atau kelas, ditakrifkan dan di-instantiate serentak — secara sejarahnya biasa untuk pengendali peristiwa dan callback. Java moden sering menggantikan ini dengan **lambda** apabila sasarannya ialah functional interface:

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

## Mengapa ia penting

Nested classes ialah alat yang berguna untuk **mengumpulkan secara logik** kelas yang hanya digunakan dalam satu konteks, meningkatkan enkapsulasi dan kebolehbacaan.

Memahami jenis-jenis tersebut — terutamanya **perbezaan static-lawan-inner** (static = bebas, inner = memegang rujukan instance yang melingkungi) — penting untuk kedua-dua reka bentuk dan mengelakkan pepijat: rujukan luar tersirat inner class boleh menyebabkan kebocoran memori, dan memilih static apabila anda tidak memerlukan instance luar ialah lalai yang lebih kemas.

Anonymous classes ialah cara klasik untuk menyediakan pelaksanaan sebaris (pengendali peristiwa, comparator), dan mengetahui bahawa ia sebahagian besarnya digantikan oleh lambda untuk functional interface mencerminkan kefasihan Java moden.

Kesemua ini muncul di seluruh pustaka standard (cth. `Map.Entry` ialah nested interface, builder ialah static nested class), menjadikannya pengetahuan praktikal yang kerap ditemui.

1. Static nested class — bebas daripada satu instance

2. Inner (non-static) class — terikat kepada satu instance

3. Local class — ditakrifkan di dalam satu kaedah

4. Anonymous class — pelaksanaan sekali-guna, tiada nama

Mengapa ia penting

Soalan berkaitan