Sunteți pe pagina 1din 15

Tipuri de clase.

Clase interne
profesor Dobrovolischii Olga
Clase imbricate(Nested classes)

Atunci cînd o clasă este declarată în interiorul altei clase spunem că clasa
respectivă este imbricată, respectiv clasa se numește clasa imbricată(nessted
clases, clase încuibate). Clasa de bază se numește 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.

Sintaxa:

public class A_ClasaDeAcoperire{


class B_ClasaImbricată{
...}
…}

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ă să fie folosită
desinestă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:
Caracteristicile claselor nestatice

➢ Se mai numesc interne(non-static nested classes, inner classes).


➢ sunt declarate fără modificatorul static, are 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 acoperire
➢ nu poate conține membri statici în interiorul ei , excepție fiind constanta,
final static
➢ pot fi clase de acoperire pentru alte clase
➢ pot implementa interfețe
➢ sintaxa de instanțiere din exterior a unei clase interne este următoarea:

ClasaDeAcoperire obAcoperire = new ClasaDeAcoperire();


ClasaDeAcoperire.ClasaInterna obIntern = ob.Acoperire.new ClasaInterna();
Exemplu 1:
public class ClasaDeAcoperire {
int num = 2;
static int x = 3;

class ClasaInterna {
public void print() {
System.out.println("Aceasta este o clasa
interna");
System.out.println("Pot accesa variabila de
intanta 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();

}}
Exemplu 2:
public class ClasaDeAcoperire1 {
int num;
ClasaInterna x = new ClasaInterna();

class ClasaInterna {
public void print() {
System.out.println("Aceasta este o clasa
interna");
}}}

class Testare1 {

public static void main(String[] args) {


ClasaDeAcoperire1 ob = new ClasaDeAcoperire1();
ob.x.print();

}}
Caracteristicile claselor statice:

➔ sunt declarate cu ajutorul modificatorului static


➔ pot fi declarate abstracte sau finale
➔ pot conține membri statici
➔ nu au acces direct la membrii clasei externe care sunt nestatic, accesul fiind
realizat doar prin intermediul obiectelor
➔ pentru a crea un obiect al clasei imbricate statice respectăm sintaxa

ClasaDeAcoperire.clasaStatica obStatica=new ClasaDeAcoperire.clasaStatică


Exemplu 3:
public class DeAcoperire3 {
static class ImbricataStatica {
public void afiseaza() {
System.out.println("Mesaj din
clasa statica");
}
}

public static void main(String[] args) {


DeAcoperire3.ImbricataStatica ob = new DeAcoperire3.ImbricataStatica();
ob.afiseaza();

}
Exemplu 4:
public class DeAcoperire4 {
public int MembruDeAcoperire = 2;

class ClasaNonStatica {
private int i = 1;

public int valoare() {


return i + MembruDeAcoperire;
}}

static class ClasaStatica {


public int k = 99;
public int valoare() {
DeAcoperire4 ob = new DeAcoperire4();
k += ob.MembruDeAcoperire;
return k;
}}}
class Test4 {
public static void main(String[] args) {
DeAcoperire4 ob = new DeAcoperire4();
// instantiere corecta a clasei non statica
DeAcoperire4.ClasaNonStatica nonSt = ob.new ClasaNonStatica();
System.out.println(nonSt.valoare());
// instantiere corecta a clasei statice
DeAcoperire4.ClasaStatica st = new DeAcoperire4.ClasaStatica();
System.out.println(st.valoare());}}
Rețineți:

1. Dacă în exemplul 4 vom încerca în cadrul clasei ClasaStatică să folosim


construcția k+=MembruDeAcoperire; vom obține eroare de compilare.
2. Dacă în cadrul metodei main() vom folosi construcția
DeAcoperire.ClasaStatică st= new ClasaStatica(); vom obține
eroare de compilare, nu este respectată sintaxa de instanțiere a unei clase
imbricată statică.
3. Clasele statice pot fi declarate cu orice tip de modificatori(public, protected,
private,default)
4. O clasă de acoperire poate avea orice număr de obiecte de tipul claselor
imbricate în interiorul ei.
5. Clasele interne pot fi declarate nu doar în interiorul unei clase, dar și în
corpul unei metode sau în corpul unei alte instrucțiuni
Clasificarea claselor interne

Locale Anonime

Caracteristicile claselor nestatice locale


❏ sunt definite într-un bloc ce conține una sau mai multe declarații incluse în {}, acesta
poate fi corp de clasă, corp de metodă sau corp de instrucțiune;
❏ sunt vizibile doar în blocul care au fost implementate, deci pot fi instanțiate doar în
blocul dat;
❏ nu pot fi private, publice , protected sau statice, pot fi finale sau abstracte
❏ sunt rar utilizate din cauza codului lizibil pe care îl crează, acestea există și pot fi
utilizate la dorința programatorului.
❏ Sunt de trei tipuri:
a. declarate direct în corpul unei clase
b. în corpul unui bloc de instrucțiuni
c. declarate în corpul unei metode(nu pot folosi variabilele declarate în metoda respectivă
și nici parametrii metodei, pentru a le accesa acestea trebuie să fie declarate final)
Exemplul 5:
public class DeAcoperire5 {
int x = 0;
class Interna {
public int f() {
return x + 1;
}}
public void g(final int j) {
final int k = j;
class LocalaMetoda {
public int f() {
return k + j;}}
LocalaMetoda i1 = new LocalaMetoda();
System.out.println(i1.f());
}}
class Test5 {
public static void main(String[] args) {
DeAcoperire5 t1 = new DeAcoperire5();
DeAcoperire5.Interna i2 = t1.new Interna();
System.out.println(i2.f());
t1.g(3);

}}
Caracteristicile claselor anonime

● sunt clase locale, fără nume


● nu au constructor
● nu pot extinde clase sau implementa interfețe
● extind o altă clasă sau implemntează 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 unei metode
pentru un singur obiect, iar crearea unei clase obișnuite special pentru
aceasta nu are rost
● sunt pe larg utilizate în lucrul cu interfețele grafice
● se folosesc atunci cînd avem nevoie de o singură instanță pentru o clasă
● nu pot fi public, private, protected sau static
Sintaxa claselor anonime: A a = new A(){
//descrierea membrilor clasei
Exemplu: };

public class Mesaj {


public void afiseaza() {
System.out.println("Mesaj din clasa Mesaj");
}
}
class Test6 {

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();
}}