Tip de date enumerare

 

În Java, de asemenea pot fi implementate enumerările. O enumerare este un tip de date ce are un set fix de valori constante. Folosim cuvântul cheie enum pentru a declara tip de date enumerare, iar valorile constante se vor specifica în {}. Conform convenției de programare aceste trebuie scrise cu majusculă.

De exemplu:

enum ZileLucratoare {

   LUNI, MARTI, MIERCURI, JOI, VINERI

}

 

Folosim numele enumerării pentru a accesa valorile constante:

enum ZileLucratoare {     LUNI, MARTI, MIERCURI, JOI, VINERI } public class Enumerare1 {     public static void main(String[] args) {         System.out.println(ZileLucratoare.LUNI);         System.out.println(ZileLucratoare.MARTI);     } }

 

De asemenea, putem crea variabile de tipuri de enumerare și pot fi utilizate în cadrul altor instrucțiuni Java cum ar fi switch.

De exemplu:

enum ZileLucratoare {     LUNI, MARTI, MIERCURI, JOI, VINERI } class EnumerareSwitch{     ZileLucratoare  zi;     public EnumerareSwitch(ZileLucratoare  zi) {         this.zi = zi;     }     public void afisareTask() {         switch(zi) {             case LUNI:               System.out.println("Analiza specificului companiei");                 break;             case MARTI:                 System.out.println("Analiza sarcinii.");                 break;             default:                 System.out.println("Nu mai avem task-uri");                 break;   }    }} class TestEnumerareSwitch{     public static void main(String[] args) {       EnumerareSwitch ob = new EnumerareSwitch(ZileLucratoare.LUNI);       ob.afisareTask();     } }

 

Clase interne

 

Î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ă! ❤️