Apa saja jenis-jenis nested class di Java?

Question

IT Interview Practice · Accepted Answer

Sebuah **nested class** adalah kelas yang didefinisikan di dalam kelas lain. Java memiliki empat jenis — **static nested**, **inner (non-static)**, **local**, dan **anonymous** — masing-masing dengan akses berbeda ke kelas yang mengelilinginya dan kasus penggunaan yang berbeda.

## 1. Static nested class — independen dari sebuah 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
```

Sebuah kelas `static` nested berperilaku seperti kelas top-level tetapi berada dalam namespace di dalam kelas luar. Kelas ini **tidak** memiliki referensi ke instance luar — digunakan untuk mengelompokkan helper (misalnya `Builder`, `Node` dalam struktur data).

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

Kelas **inner** non-static memiliki referensi implisit ke instannya yang mengelilingi, sehingga dapat mengakses field instance dari objek luar. (Perhatian: referensi ini dapat menyebabkan **memory leaks** jika instance inner bertahan lebih lama dari yang luar.)

## 3. Local class — didefinisikan di dalam sebuah method

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

Jarang digunakan; dibatasi lingkupnya pada method.

## 4. Anonymous class — implementasi sekali pakai, tanpa 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"); }
};
```

Sebuah **anonymous** class adalah implementasi satu kali dari interface atau kelas, didefinisikan dan diinstansiasi sekaligus — secara historis umum untuk event handler dan callback. Java modern sering mengganti ini dengan **lambdas** ketika target adalah functional interface:

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

## Mengapa ini penting

Nested class adalah alat yang berguna untuk **mengelompokkan kelas secara logis** yang hanya digunakan dalam satu konteks, meningkatkan encapsulation dan readability.

Memahami jenis-jenisnya — terutama perbedaan **static-vs-inner** (static = independen, inner = memiliki referensi enclosing-instance) — penting untuk desain dan menghindari bug: referensi luar implisit inner class dapat menyebabkan memory leak, dan memilih static ketika Anda tidak memerlukan instance luar adalah default yang lebih bersih.

Anonymous class adalah cara klasik untuk memberikan implementasi inline (event handler, comparator), dan mengetahui bahwa sebagian besar digantikan oleh lambda untuk functional interface mencerminkan fluency Java modern.

Nested class muncul di seluruh standard library (misalnya `Map.Entry` adalah nested interface, builder adalah static nested class), menjadikan mereka pengetahuan praktis yang sering ditemui.

1. Static nested class — independen dari sebuah instance

2. Inner (non-static) class — terikat ke sebuah instance

3. Local class — didefinisikan di dalam sebuah method

4. Anonymous class — implementasi sekali pakai, tanpa nama

Mengapa ini penting

Pertanyaan terkait