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