Differences
This shows you the differences between two versions of the page.
|
poo-ca-cd:laboratoare:abstractizare-clase-speciale-si-restrictii [2025/10/27 01:02] florian_luis.micu [🌀 Abstractizare] |
poo-ca-cd:laboratoare:abstractizare-clase-speciale-si-restrictii [2025/10/27 01:22] (current) florian_luis.micu [Exerciții] |
||
|---|---|---|---|
| Line 35: | Line 35: | ||
| ====Clase și metode abstracte==== | ====Clase și metode abstracte==== | ||
| - | Programarea orientată pe obiecte permite modelarea unor concepte generale care pot avea comportamente variate în funcție de implementare. Clasele și metodele abstracte oferă un mecanism esențial pentru proiectarea ierarhiilor de clase flexibile și extensibile. | + | Programarea orientată pe obiecte permite modelarea unor concepte generale care pot avea comportamente variate în funcție de implementare. Clasele și metodele abstracte oferă un mecanism esențial pentru proiectarea ierarhiilor de clase **flexibile** și **extensibile**. |
| ===Ce este o metodă abstractă?=== | ===Ce este o metodă abstractă?=== | ||
| Line 84: | Line 84: | ||
| <note important> | <note important> | ||
| - | Este important să înțelegem că dacă avem cel puțion o metodă abstractă, trebuie să declarăm și clasa acesteia ca fiind abstractă. | + | Este important să înțelegem că dacă avem **cel puțin o metodă abstractă**, trebuie să declarăm și clasa acesteia ca fiind abstractă. |
| </note> | </note> | ||
| Line 95: | Line 95: | ||
| O clasă abstractă, **nu poate fi instanțiată direct**, trebuie moștenită de o altă clasă folosind keyword-ul ''extends''. | O clasă abstractă, **nu poate fi instanțiată direct**, trebuie moștenită de o altă clasă folosind keyword-ul ''extends''. | ||
| - | Acest mecanism funcționează și pe lanțuri de moștenire între clase abstracte: o clasă abstractă poate moșteni o altă clasă abstractă și poate adăuga metode abstracte noi. Toate metodele abstracte din lanț trebuie să fie implementate în cele din urmă într-o clasă concretă pentru a putea crea obiecte. | + | Acest mecanism funcționează și pe **lanțuri de moștenire** între clase abstracte: o clasă abstractă poate moșteni o altă clasă abstractă și poate adăuga metode abstracte noi. Toate metodele abstracte din lanț **trebuie să fie implementate** în cele din urmă într-o clasă concretă pentru a putea crea obiecte. |
| <code java Vehicle.java> | <code java Vehicle.java> | ||
| Line 154: | Line 154: | ||
| <note important> | <note important> | ||
| - | * Clasa ''Vehicle'' și clasa ''Car'' nu pot fi instanțiate, deoarece nu implementează toate metodele abstracte moștenite și proprii. | + | * Clasa ''Vehicle'' și clasa ''Car'' nu pot fi instanțiate, deoarece **nu implementează** toate metodele abstracte moștenite și proprii. |
| - | * Dacă dorim să nu se poată instanția clasa ''Animal'' de mai sus, am putea să o declarăm ca fiind abstractă chiar dacă aceasta nu ar avea metode abstracte:<code java> | + | * Dacă dorim să nu se poată instanția clasa ''Animal'' de mai sus, am putea să o declarăm ca fiind abstractă chiar dacă aceasta **nu** ar avea metode abstracte:<code java> |
| public abstract class Animal { // valid | public abstract class Animal { // valid | ||
| private double weight; | private double weight; | ||
| Line 171: | Line 171: | ||
| <note tip> | <note tip> | ||
| - | * O clasă abstractă nu poate fi instanțiată, deoarece o clasă abstractă poate conține metode abstracte care nu au încă o implementare. Chiar și dacă clasa nu conține metode abstracte această restricție este păstrată pentru a putea exista scenariul de mai sus. | + | * O clasă abstractă nu poate fi instanțiată, deoarece o clasă abstractă **poate** conține metode abstracte care nu au încă o implementare. Chiar și dacă clasa **nu** conține metode abstracte această restricție este păstrată pentru a putea exista scenariul de mai sus. |
| - | * O clasă abstractă poate avea constructori chiar dacă nu poate fi instanțiată direct, deoarece acei constructori pot fi folosiți la inițializarea stării interne a clasei, ca în exemplul de mai sus. | + | * O clasă abstractă poate avea constructori chiar dacă nu poate fi instanțiată direct, deoarece acei constructori pot fi folosiți la **inițializarea stării interne** a clasei, ca în exemplul de mai sus. |
| </note> | </note> | ||
| Line 197: | Line 197: | ||
| ====Interfețe==== | ====Interfețe==== | ||
| - | Interfețele oferă un mecanism prin care putem defini **comportamente** fără a impune moștenire de implementare. Ele stabilesc un contract pe care orice clasă îl poate îndeplini, indiferent din ce parte a ierarhiei de clase provine. | + | Interfețele oferă un mecanism prin care putem defini **comportamente** fără a forța clasele să moștenească implementarea. Ele stabilesc un contract pe care orice clasă îl poate îndeplini, indiferent din ce parte a ierarhiei de clase provine. |
| ===Ce este o interfață?=== | ===Ce este o interfață?=== | ||
| Line 271: | Line 271: | ||
| ===Iniţializarea câmpurilor în interfeţe=== | ===Iniţializarea câmpurilor în interfeţe=== | ||
| - | În interfețe toate câmpurile sunt implicit ''public static final''. Nu pot exista **blank final**s (câmpuri finale neinițializate), dar pot exista constante non-primitive dacă sunt inițializate la declarație. | + | În interfețe toate câmpurile sunt implicit ''public static final''. Nu pot exista **blank finals** (câmpuri finale neinițializate), dar pot exista **constante non-primitive** dacă sunt inițializate la declarație. |
| <code java> | <code java> | ||
| Line 281: | Line 281: | ||
| ===Interfețele ca tipuri=== | ===Interfețele ca tipuri=== | ||
| - | După ce definim o interfață, ea devine un tip de referință în Java, la fel ca o clasă. Asta înseamnă că putem: | + | După ce definim o interfață, ea devine un **tip de referință** în Java, la fel ca o clasă. Asta înseamnă că putem: |
| * Declara variabile de tipul interfeței | * Declara variabile de tipul interfeței | ||
| * Folosi interfața ca tip pentru parametrii unor metode | * Folosi interfața ca tip pentru parametrii unor metode | ||
| * Specifica interfața ca tip de return al unei metode | * Specifica interfața ca tip de return al unei metode | ||
| - | Astfel, orice obiect care implementează interfața poate fi atribuit unei variabile de acel tip, indiferent de clasa sa concretă. | + | Astfel, orice obiect care implementează interfața poate fi atribuit unei variabile de acel tip, indiferent de clasa sa concretă (upcasting). |
| <code java> | <code java> | ||
| Line 334: | Line 334: | ||
| ===Moștenire multiplă=== | ===Moștenire multiplă=== | ||
| - | În Java, o interfață poate moșteni mai multe interfețe folosind keyword-ul extends. Aceasta permite combinarea comportamentelor din mai multe surse fără a fi nevoie de moștenire multiplă de clase (care nu este permisă în Java). | + | În Java, **o interfață** poate moșteni **mai multe interfețe** folosind keyword-ul ''extends''. Acesta permite combinarea comportamentelor din mai multe surse fără a fi nevoie de moștenire multiplă de clase (care nu este permisă în Java). |
| <code java> | <code java> | ||
| Line 357: | Line 357: | ||
| </code> | </code> | ||
| - | Totodată, o clasă poate moșteni mai multe interfețe folosind keyword-ul ''implements'': | + | Totodată, **o clasă** poate moșteni **mai multe interfețe** folosind keyword-ul ''implements'': |
| <code java> | <code java> | ||
| Line 412: | Line 412: | ||
| </code> | </code> | ||
| - | <note tip>Situația de mai sus **nu** reprezintă //Problema diamantului//, deoarece chiar dacă se pot moșteni mai multe interfețe, acestea nu au un corp, deci implementarea este lăsată la latitudinea clasei care le va implementa.</note> | + | <note tip>Situația de mai sus **nu** se încadrează la //Problema diamantului//, deoarece chiar dacă se pot moșteni mai multe interfețe, acestea nu au un corp, deci implementarea este lăsată la latitudinea clasei care le va implementa.</note> |
| <spoiler [Optional] Metode default în interfețe și Problema diamantului> | <spoiler [Optional] Metode default în interfețe și Problema diamantului> | ||
| **Metode default în interfețe** | **Metode default în interfețe** | ||
| - | În Java (de la Java 8), interfețele pot avea metode cu implementare folosind cuvântul cheie ''default''. | + | În Java (de la Java 8), interfețele pot avea **metode cu implementare** folosind cuvântul cheie ''default''. |
| Scopul lor: | Scopul lor: | ||
| Line 479: | Line 479: | ||
| ====Clase abstracte vs. Interfețe==== | ====Clase abstracte vs. Interfețe==== | ||
| - | După cum se poate observa, atât clasele abstracte cât și interfețele oferă avantaje similare. Pentru a observa asemănările și diferențele dintre acestea am creat următorul tabel: | + | După cum se poate observa, atât clasele abstracte cât și interfețele oferă avantaje similare. Să observăm următorul tabel pentru o comparație directă: |
| ^ Caracteristică ^ Clasă abstractă ^ Interfață ^ | ^ Caracteristică ^ Clasă abstractă ^ Interfață ^ | ||
| Line 494: | Line 494: | ||
| ====Exemplu ierarhie de clase==== | ====Exemplu ierarhie de clase==== | ||
| - | Proiectele voastre ar trebui să conțină o combinație între clase abstracte și interfețe. | + | Un proiect complex ar trebui să conțină o **combinație** între clase abstracte și interfețe. |
| - | Să presupunem următoarea ierarhie de clase. | + | Să presupunem următoarea ierarhie de clase: |
| {{:poo-ca-cd:laboratoare:abstractizare-clase-speciale-si-restrictii:inheritance_example.png?nolink&600|}} | {{:poo-ca-cd:laboratoare:abstractizare-clase-speciale-si-restrictii:inheritance_example.png?nolink&600|}} | ||
| Line 654: | Line 654: | ||
| ====Enums==== | ====Enums==== | ||
| - | Enums sunt tipuri speciale de clasă care definesc un set fix de constante. Ele oferă o modalitate sigură și lizibilă de a reprezenta valori finite și constante într-un program. | + | Enums sunt tipuri speciale de clasă care definesc un **set fix de constante**. Ele oferă o modalitate **sigură** și **lizibilă** de a reprezenta **valori finite** și **constante** într-un program. |
| Exemplu simplu: | Exemplu simplu: | ||
| Line 762: | Line 762: | ||
| ===Avantaje ale folosirii Enum=== | ===Avantaje ale folosirii Enum=== | ||
| - | * Cod mai clar și mai lizibil comparativ cu constantele int sau String. | + | * Cod mai clar și mai lizibil comparativ cu constantele de tip ''int'' sau ''String''. |
| - | * Siguranță la compilare: nu poți atribui valori invalide. | + | * Siguranță la compilare, deoarece nu putem atribui valori invalide. |
| - | * Poți adăuga metode și comportamente specifice fiecărei constante. | + | * Putem adăuga metode și comportamente specifice fiecărei constante. |
| * Se integrează bine cu switch/case pentru decizii pe valori finite. | * Se integrează bine cu switch/case pentru decizii pe valori finite. | ||
| <note tip> | <note tip> | ||
| - | Puteți folosi în continuare câmpuri de tipul ''static final'' într-o clasă normală care are rol de a ține constante, însă este de preferat să folosiți Enum-uri fiind o alternativă mai modernă. | + | Puteți folosi în continuare câmpuri de tipul ''static final'' într-o clasă normală care are rol de a ține constante, însă este de **preferat** să folosiți Enum-uri fiind o alternativă mai modernă cu toate avantajele de mai sus. |
| </note> | </note> | ||
| Line 946: | Line 946: | ||
| * Exercițiile vor fi făcute pe platforma [[https://code.devmind.ro/|Devmind Code]]. Găsiți exercițiile din acest laborator în **contestul aferent**. | * Exercițiile vor fi făcute pe platforma [[https://code.devmind.ro/|Devmind Code]]. Găsiți exercițiile din acest laborator în **contestul aferent**. | ||
| * Vă recomandăm să copiați scheletul și să faceți exercițiile **mai întâi** în IntelliJ, deoarece acolo aveți acces la o serie de **instrumente** specifice unui IDE. După ce ați terminat exercițiile puteți să le **copiați** pe Devmind Code. | * Vă recomandăm să copiați scheletul și să faceți exercițiile **mai întâi** în IntelliJ, deoarece acolo aveți acces la o serie de **instrumente** specifice unui IDE. După ce ați terminat exercițiile puteți să le **copiați** pe Devmind Code. | ||
| + | </note> | ||
| + | |||
| + | <note note> | ||
| + | În contest veți observa că problema se cheamă //Problem-LAB05-POO//, însă nu este o problemă. Vom redenumi numele problemei cât de curând. | ||
| </note> | </note> | ||
| Line 955: | Line 959: | ||
| * Un task (''CounterOutTask.java'') care incrementeaza un contor global și afișează valoarea contorului după fiecare incrementare. | * Un task (''CounterOutTask.java'') care incrementeaza un contor global și afișează valoarea contorului după fiecare incrementare. | ||
| - | <note>**Notă**: Acesta este un exemplu simplu pentru [[http://en.wikipedia.org/wiki/Command_pattern|Command Pattern]]</note> | + | <note>**Notă**: Acesta este un exemplu simplu pentru Design Pattern-ul [[http://en.wikipedia.org/wiki/Command_pattern|Command Pattern]], despre care vom învăța în următoarele laboratoare.</note> |
| {{:poo-ca-cd:laboratoare:clase-abstracte-interfete:ex1.png?600|}} | {{:poo-ca-cd:laboratoare:clase-abstracte-interfete:ex1.png?600|}} | ||
