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.
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).
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.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Jarang digunakake; dipengerteni menyang method.
// 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:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
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.
Pustaka pitakon wawancara IT kanthi jawaban rinci — saka Junior nganti Senior.
Nyumbang