În Java, este posibil să se declare o
clasă în cadrul altei clase. Aceasta fiind numită clasă imbricată (nested classes, clase încuibate). Clasa externă se numește clasă
de bază (de acoperire).
Acestea permit gruparea claselor care
sunt legate logic și controlul vizibilității uneia din cadrul celorlalte.
Vizibilitatea și domeniul de aplicare al
clasei imbricate este delimitată de clasa în care este declarată. Astfel, dacă
o clasă B este declarată în cadrul
clasei A, înseamnă că existența
clasei B depinde de existența clasei
A. Clasa imbricată, B, este un membru al clasei A.
Spre deosebire de clasele obișnuite,
clasele interne pot fi statice și/sau private. O clasă de acoperire poate avea orice număr de obiecte
de tipul claselor imbricate în interiorul ei.
Sintaxa:
|
public
class A_ClasaDeAcoperire{
class B_ClasaImbricata{
...}
...}
|
Clasele imbricate se folosesc atunci
când o clasă are nevoie în implementarea sa de o altă clasă şi nu există motiv
pentru care clasa imbricată se fie
folosită de sine stătătoare (nu mai este folosită nicăieri).
La fel ca și câmpurile, metodele,
blocurile de inițializare, acestea sunt de două tipuri statice și nestatice care
la rândul lor sunt de diverse tipuri.
Clase imbricate statice posedă următoarele caracteristici:
ü sunt declarate cu ajutorul modificatorului static;
ü pot fi declarate abstracte sau finale;
ü pot fi declarate cu orice tip de modificatori (public,
protected, private, implicit);
ü pot defini constructor;
ü pot defini atât membri statici, cât și de instanță;
ü nu au acces direct la membrii clasei externe care sunt
nestatici, accesul fiind realizat doar prin intermediul obiectelor;
ü există independent de
instanțele clasei exterioare;
ü pentru a crea un obiect al clasei imbricate statice
respectăm sintaxa:
ClasaDeBaza.clasaStatica obStatica =
new ClasaDeBaza.clasaStatica();
Exemplul
1:
|
class DeAcoperire {
static
class ImbricataStatica {
public void afiseaza() {
System.out.println("Mesaj din clasa statica");
}
}
public
static void main(String args[]) {
DeAcoperire.ImbricataStatica ob = new DeAcoperire.ImbricataStatica();
ob.afiseaza();
}
}
|
La ecran se va afișa Mesaj din clasa statica
Clase imbricate nestatice posedă următoarele caracteristici:
ü Se mai numesc interne (non - static nested classes,
inner classes).
ü sunt declarate fără modificatorul static, au acces direct la membrii clasei externe fără a
declara un obiect al clasei externe, chiar dacă aceștia sunt declarați private;
ü o clasă internă nu este accesibilă direct din exteriorul clasei de bază;
ü nu pot conţine membri statici în interiorul lor, excepție
fiind constanta final
static;
ü pot fi clase de acoperire pentru alte clase;
ü pot implementa interfețe;
ü sunt legate de o instanță a clasei exterioare;
ü sintaxa de instanțiere din exterior a unei clase
interne este următoarea:
ClasaDeBaza obClasaBaza = new ClasaDeBaza();
ClasaDeBaza.ClasaInterna obIntern = obClasaBaza.new
ClasaInterna();
sau: DeBaza.InternaNeStatica ob = new DeBaza().new InternaNeStatica();
Exemplul 2:
|
class
ClasaDeAcoperire{
int num=2;
static int x=3;
class ClasaInterna {
public
void print() {
System.out.println("Aceasta
este o clasă internă");
System.out.println("Pot
accesa variabila de instanta num = "+ num);
System.out.println("Pot
accesa variabila de clasa x = "+ x);
}
}}
class Testare {
public static void
main(String args[]) {
ClasaDeAcoperire ob = new
ClasaDeAcoperire();
ClasaDeAcoperire.ClasaInterna x = ob.new
ClasaInterna();
x.print();
}}
|
Exemplul 3:
|
class ClasaDeAcoperire{
ClasaInterna x = new
ClasaInterna();
class ClasaInterna {
public void print() {
System.out.println("Aceasta este o clasă internă");
}
}}
class Testare {
public
static void main(String args[]) {
ClasaDeAcoperire ob = new
ClasaDeAcoperire();
ob.x.print();
}}
|
Deoarece clasa
imbricată este un membru al clasei sale exterioare, puteți utiliza notația
punct (.) pentru a accesa clasa imbricată și membrii acesteia: ob.x.print();
Clasele interne nestatice sunt de 2 tipuri : locale și
anonime.
Clase imbricate nestatice locale posedă următoarele caracteristici:
-
pot
fi definite în corp de clasă, corp de metodă sau corp de instrucțiune;
-
sunt
vizibile doar în blocul în care au fost implementate, deci pot fi instanțiate
doar în blocul dat;
-
nu
pot fi private, publice, protected sau static, pot fi finale sau abstracte;
-
nu
pot conține în corpul lor câmpuri și metode statice;
-
sunt
rar utilizate din cauza codului lizibil pe care îl creează, dar acestea există
și pot fi utilizate la dorința programatorului;
-
sunt
de trei tipuri:
a) declarate în direct în corpul unei
clase (exemplul de mai sus);
b) în corpul unui bloc de instrucțiuni;
c)
declarate în
corpul unei metode ( nu pot folosi variabilele declarate în metoda respectivă
și nici parametri metodei, pentru a le putea accesa acestea trebuie să fie
declarate final);
Exemplul 4:
|
class ClasaExerna {
private int x = 5;
public void metoda1() {
class InMetoda{
public void afisare() {
x= x+3;
System.out.println("Valoarea lui x din
clasă locală în metodă: " + x);
}}
InMetoda obLocal = new InMetoda();
obLocal.afisare();
}
public static void main(String[] args) {
ClasaExerna obj = new ClasaExerna();
obj.metoda1();
}}
|
Clase imbricate nestatice anonime posedă următoarele caracteristici:
- sunt clase locale fără nume.
- nu au constructor.
- nu pot extinde clase sau implementa interfeţe.
- extind o altă clasă sau implementează o interfaţă prin
instanţierea acesteia cu ajutorul operatorului new().
- nu pot conţine declaraţii statice.
- se folosesc efectiv atunci când este nevoie de supradefinirea
metodelor pentru un singur obiect, iar
crearea unei clase obişnuite special pentru acesta nu are rost.
- sunt pe larg utilizate la gestionarea evenimentelor în
interfeţe grafice cu utilizatorul în cadrul metodelor de tip listener.
- se folosesc atunci când avem nevoie de o sigură
instanţă pentru o clasă.
- nu pot fi public, private, protected sau static.
Sintaxa:
NumeClasa_Interfata numeObiect = new NumeClasa_Interfata(){
//descrierea membrilor
clasei anonime
};
Exemplul
5:
|
class Mesaj {
public void afiseaza() {
System.out.println("Mesaj din clasa Mesaj");
}
}
class TestMesaj{
public static void main(String[] args) {
Mesaj ob1 = new Mesaj(){
public void afiseaza(){
System.out.println("Mesaj
din clasa Test");
}};
ob1.afiseaza();
Mesaj ob2 = new Mesaj();
ob2.afiseaza();
}}
|
Exemplul 6:
|
interface MMesaj {
void afiseaza1();
void afiseaza2();
}
class TestMMesaj {
public static void main(String[] args) {
MMesaj ob1 = new MMesaj() {
public void afiseaza1() {
System.out.println("Afiseaza 1 din
clasa Test");
}
public void afiseaza2() {
System.out.println("Afiseaza
2 din clasa Test");
}
};
ob1.afiseaza1();
ob1.afiseaza2();
}
}
|
Alegerea tipului de clasă internă depinde de mai mulți factori, cum ar fi:
|
Diferență
|
Nestatice
|
Statice
|
Anonime
|
|
Accesul la membrii clasei exterioare
|
Au acces la toți membrii clasei exterioare, inclusiv
cei privați.
|
Au acces doar la membrii statici ai clasei exterioare.
|
Au acces doar la membrii finali ai clasei
exterioare.
|
|
Vizibilitatea
|
Pot fi public, private, protected sau default.
|
Pot fi public, private sau protected.
|
Nu pot avea modificatori de vizibilitate.
|
|
Durata de viață
|
Sunt legate de o instanță a clasei exterioare.
|
Există independent de instanțele clasei exterioare.
|
Există doar în cadrul metodei în care sunt
declarate.
|
|
Utilizare
|
Pot fi utilizate pentru a implementa comportamente
legate de o instanță specifică a clasei exterioare.
|
Pot fi utilizate pentru a implementa comportamente
legate de clasa exterioară în general.
|
Pot fi utilizate pentru a implementa comportamente
ad-hoc, de unică folosință.
|
Din punct
de vedere al POO, pentru a asigura reutilizare și flexibilitate/extensibilitate
trebuie să vă mențineți clasele cât mai specifice. Adică, o clasă trebuie să
conțină cod numai pentru lucrurile pe care trebuie să le facă un obiect al
acelui tip; orice alt comportament ar trebui să facă parte dintr-o altă clasă
mai potrivită pentru acea funcționalitate.
Unul dintre motivele
principale pentru utilizarea claselor interioare este capacitatea de a fi o
subclasă a oricărei clase, indiferent dacă clasa de bază are o superclasă sau
nu. Utilizarea acestor tipuri de clase rămâne la discreția programatorului.
👌 Analizează și discută!
Lucrați în pereche cu colegul de bancă. Realizați în caiete
diagrama UML al următorului proiect astfel încât să utilizați clase concrete,
clase abstracte, interfețe, clase interne.
Proiect. Planificare produsului software Management Parc
Auto.
Descriere: Acest proiect are ca scop implementarea unui sistem simplu
de management pentru un parc auto.
Funcționalități:
-
Înregistrarea
vehiculelor (mașini, camioane, motociclete)
-
Adăugarea
de informații detaliate despre vehicule (model, an, kilometraj, etc.)
-
Efectuarea
de reparații și revizii
-
Urmărirea
costurilor de întreținere
-
Generarea
de rapoarte
Vă doresc o zi deosebit de frumoasă! ❤️
