O clasă imbricată este o clasă definită în interiorul unei alte clase. Java are patru tipuri — imbricată statică, internă (non-statică), locală și anonimă — fiecare cu acces diferit la clasa încapsulantă și cazuri de utilizare diferite.
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
O clasă imbricată static se comportă ca o clasă de top-nivel, dar este namespaced în interiorul celei exterioare. Nu ține o referință la o instanță exterioară — folosită pentru gruparea ajutoarelor (de exemplu, un Builder, Node într-o structură de date).
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
O clasă internă non-statică ține o referință implicită la instanța sa încapsulantă, deci poate accesa câmpurile de instanță ale obiectului exterior. (Atenție: această referință poate provoca scurgeri de memorie dacă instanța internă supraviețuiește celei exterioare.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Rar utilizată; limitată la domeniul metodei.
// 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"); }
};
O clasă anonimă este o implementare unică a unei interfețe sau clase, definită și instanțiată deodată — istoric frecventă pentru handlere de evenimente și callback-uri. Java modern adesea înlocuiește acestea cu lambda-uri atunci când ținta este o interfață funcțională:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Clasele imbricate sunt un instrument util pentru gruparea logică a claselor care sunt utilizate doar într-un context, crescând încapsularea și lizibilitatea.
Înțelegerea tipurilor — în special distincția static-vs-inner (static = independent, inner = ține o referință la instanța încapsulantă) — contează atât pentru proiectare, cât și pentru evitarea erorilor: referința implicită a clasei exterioare în clase interne poate provoca scurgeri de memorie, iar alegerea static atunci când nu aveți nevoie de instanța exterioară este alegerea mai curată și implicită.
Clasele anonime au fost modalitatea clasică de a furniza implementări inline (handlere de evenimente, comparatoare), iar cunoașterea că sunt în mare măsură înlocuite de lambda-uri pentru interfețe funcționale reflectă cunoștințele Java moderne.
Acestea apar în întreaga bibliotecă standard (de exemplu, Map.Entry este o interfață imbricată, builder-ii sunt clase imbricate statice), făcând din ele cunoștințe practice și frecvent întâlnite.
O bibliotecă de întrebări de interviu IT cu răspunsuri detaliate — de la Junior la Senior.
Donează