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
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
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
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
// 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:
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.