Clase și metode abstracte set de probleme

Aceste probleme se vor realiza în baza noțiunilor studiate la instruirea teoretică:  https://musteatadidactic.blogspot.com/2026/03/clase-si-metode-abstracte.html

---

1. Deschideți editorul de cod Java și rulați Exemplul 1 din partea teoretică. Apoi realizați următoarele modificări:
a. Adăugați clasei Figura metoda: static void afisare(String autor) care va afișa autorul programului.     Testați metoda în main().
b. Adăugați o nouă subclasă pentru clasa Figura. Instanțiați subclasa în main().

---

2. Se cere realizarea unei aplicații Java care să simuleze funcționarea unor aplicații digitale populare (rețele sociale, platforme educaționale, servicii de streaming).
a. Creați clasa abstractă Aplicatie, care va conține:

- atributul nume (de tip String);
- un constructor cu parametri pentru inițializarea atributului;
- metoda concretă afisareNume(), care afișează denumirea aplicației;
- metodele abstracte: login(), logout() și functionalitatePrincipala()

b. Creați cel puțin 3 clase care extind clasa Aplicatie:

- AplicatieSocialMedia (ex.: Instagram, Facebook) în care supradefiniți:

metoda login() va afișa: „Utilizatorul s-a autentificat în aplicația X”

metoda functionalitatePrincipala() va afișa: „Postează o imagine”

- AplicatieEducatie (ex.: platformă e-learning) în care supradefiniți:

metoda login() va afișa: „Utilizatorul s-a autentificat în aplicația X”

metoda functionalitatePrincipala() va afișa: „Accesează un curs”

- AplicatieStreaming (ex.: video sau muzică)

metoda login() va afișa: „Utilizatorul s-a autentificat în aplicația X”

metoda functionalitatePrincipala() va afișa: „Redă un videoclip”

c. Testarea în metoda main

- creați un array de tip Aplicatie;
- adăugați obiecte din toate cele trei tipuri de aplicații;
- parcurgeți array-ul și apelați metodele definite.

---

3. Efectuați următoarele acțiuni:
a) Având dată următoarea clasă abstractă. Transcrieți această clasă în editorul de cod Java:

abstract class Policeman {

private String nume;
private String prenume;
private int staj;
public Policeman(String n, String p,int s) {

nume = n;

prenume = p;

staj = s;

}
public String getNume() {

return nume; 

}
public String getPrenume() {

return prenume; 

}
public int getStaj() {

return staj; 

}
public abstract double venit();
public abstract int rang();

}

Vor urma 3 clase: Soldat din care se va deriva Sergent din care mai apoi se va deriva Locotenent. Metodele abstracte venit() și rang() vor fi implementate în clase. Metoda rang() va returna rangul omului legii. Va începe de la 1 pentru soldat, va urma 2 pentru sergent și 3 pentru locotenent.
b) Elaborați clasa Soldat pornind de la următorul codul sursă:

class Soldat extends Policeman {

protected static double plataBazaSoldat = 3600;
Soldat(String nume, String prenume, int staj) {

super(nume, prenume, staj);

}
public double getPlataSoldat(){

}

}

Plata de bază pentru un soldat este 3600 lei pe lună. Salariul net constituie 85% din salariul de bază + 6% din rădăcina pătrată din plata de bază înmulțit la staj. Rangul său este 1.
c) Elaborați clasa Sergent pornind de la următorul codul sursă:

class Sergent extends Soldat {

protected static double plataBazaSerjant = 4700;

public Sergent(String nume, String prenume, int staj) {

super(nume, prenume, staj); 

}

}

Plata de bază pentru un sergent este 4700 lei pe lună. Salariul net constituie 82% din salariul de bază + 1.2 înmulțit la rădăcina pătrată din plata de bază înmulțit la staj. Rangul său este de 2 ori mai mare decât rangul soldatului care trebuie obținut cu ajutorul variabilei predefinite super.

d) Elaborați clasa Locotenent pornind de la următorul codul sursă:

class Locotenent extends Serjant{

protected static double plataBazaLocotenent = 5900;

public Locotenent(String nume, String prenume, int staj) {

super(nume, prenume, staj);

}

}

Plata de bază pentru un locotenent este 5900 lei pe lună. Salariul net constituie 80% din salariul de bază + 1.3 înmulțit la rădăcina pătrată din plata de bază înmulțit la staj. Rangul său este cu o unitate mai mare decât rangul locotenentului care trebuie obținut, de asemenea, cu ajutorul variabilei predefinite super.
e) Compuneți clasa TestPolitie în care instanţiați clasele programate și testați metodele acestora. 

---

4. Modelați un sistem de calcul al salariilor pentru diferite tipuri de angajați.
a) Creați clasa abstractă Angajat, care va conține:

- atributul nume (String);

- atributul salariuBaza (double);

- constructor pentru inițializare;

- metodă concretă afisareNume();

- metode abstracte: calculeazaSalariu() și calculeazaBonus()

b) Creați cel puțin 3 clase:

- Programator. Despre programator se știe că bonus = 20% din salariul de bază și salariu final = salariuBaza + bonus.

- Manager. Despre manager se știe că bonus = 35% din salariul de bază și salariu final = salariuBaza + bonus

- Intern, despre inter se știe că bonus = 0 și salariu final = salariuBaza

c) În metoda main:

- creați un array de tip Angajat;

- adăugați obiecte (ex: 5000, 8000, 3000);

- pentru fiecare:

- afișați numele

- calculați și afișați bonusul

- calculați și afișați salariul final

- calculați salariul total al tuturor angajaților

- afișați angajatul cu salariul cel mai mare

---

5. Se dorește modelarea unui sistem de calcul al costului total pentru diferite tipuri de comenzi online.
a. Creați clasa abstractă Comanda, care va conține:

- atributul client (String);
- atributul valoareProduse (double);
- constructor pentru inițializare;
- metodă concretă afisareClient();
- metode abstracte: calculeazaLivrare() și calculeazaTotal()

b. Creați cel puțin 3 clase:

- ComandaStandard, despre care se cunoaște că costul de livrare este 50 lei, iar totalul se va calcula conform formulei: total = valoareProduse + livrare
- ComandaExpress, despre care se cunoaște că costul de livrare este 100 lei, iar totalul se va calcula conform formulei: total = valoareProduse + livrare
- ComandaPremium, despre care se cunoaște că costul de livrare este 0 lei, iar totalul se va calcula conform formulei: total = valoareProduse (livrare gratuită)

c. În metoda main:

- creați un array de tip Comanda;
- adăugați obiecte (ex: 500 lei, 300 lei etc.);
- pentru fiecare:
- afișați clientul
- calculați livrarea
- calculați totalul
- aplicați reducere de 10% pentru comenzile peste 500 lei
- afișați comanda cu cel mai mare total

Succes! 

❤️

Crearea ierarhiilor de clase (Principiul Moștenirii)

Moștenirea este unul din principiile POO şi reprezintă inima acesteia. Ideea de moștenire este una simplă, dar puternică: atunci când doriți să creați o clasă nouă și există deja o clasă care include o parte din codul dorit, puteți deriva noua clasă din clasa existentă. Făcând acest lucru, puteți reutiliza câmpurile și metodele clasei existente fără a fi nevoie să le scrieți singur, sau să le rescrieți astfel generând cod duplicat în proiectul dvs. Deci în moștenire avem: 

1. Clasa părinte (superclass, supercalsă) – conține atribute și metode generale.
2. Clasa copil (subclass, subclasă) – moștenește și poate extinde sau modifica comportamentul.

Fie că avem de creat clasele Dreptunghi, Patrat, Romb. Aceste clase au multe trăsături comune (număr de unghiuri, număr de laturi, culoare, ș.a). Folosind conceptul de moștenire vom putea implementa aceste clase ca să fie ușor de înțeles, menținut şi fără cod duplicat. Astfel vom proiecta o clasă generală (superclasă, clasă de bază, clasă părinte), de exemplu clasa Paralelogram, care să poată fi extinsă mai târziu pentru a crea clase specifice (subclase, clase copil, clase derivate), de exemplu clasele Dreptunghi, Romb, Triunghi. Clasa nouă va moșteni toate atributele și metodele clasei de bază, având posibilitatea de a avea metode și atribute proprii.

O subclasă moștenește toți membrii (câmpuri, metode și clase imbricate) din superclasa sa.

După cum am menționat la lecțiile anterioare în Java poate fi implementată doar moștenirea simplă, adică o clasă poate avea o singură superclasă sau clasă părinte.

Cu excepția clasei Object, care nu are superclasă, fiecare clasă are o singură superclasă, și numai una, directă (moștenire unică). În absența oricărei alte superclase explicite, fiecare clasă este implicit o subclasă a clasei Object.

Pentru a deriva o clasă se folosește cuvântul cheie extends în semnătura clasei copil, urmată de numele clasei părinte.

Să ne reamintim sintaxa generală de declarare a claselor:

[public][abstract][final] class nume_clasa

                               [extends nume_super_clasă]

[implements Interfata1,Interfata2,...,InterfataN]

{

     // atribute, metode, blocuri de cod, alte clase 

}

Sintaxa generală a moștenirii:

class SuperClasa

{

    // variabile ale superclasei
    // metode ale superclasei

    // metode ale superclasei

}

class SubClasa extends SuperClasa

{

    // variabile ale subclasei

    // metode ale subclasei

}

Exemplu: 

Definiți clasa Persoana caracterizată de următoarele atribute: nume. Din clasa Persoana derivați clasa Student caracterizată de atributele: nume și notă. 

class Persoana {

    String nume;

    void afiseazaNume() {

        System.out.println("Nume: " + nume);

    }

}

class Student extends Persoana {

    int nota;

    void afiseazaNota() {

        System.out.println("Nota: " + nota);

    }

}

public class Main{

public static void main(String [] args){

Student s = new Student();

s.nume = "Victoria";

s.nota = 9;

System.out.println(s.nume + " " + s.nota);

}}

Deci, Student moștenește variabila nume și metode metoda afiseazaNume(), adică are o poate apela ori de câte ori este necesar, dar adaugă și un atribut propriu care este nota.

Iată un alt exemplu de cod, pentru o posibilă implementare a unei clase Bicicleta:

public class Bicicleta {

public int cadenta;//numărul de rotații a pedalelor pe minut

public int angrenaj;

public int viteza;

public Bicicleta (int startCadenta, int startViteza, int startAngrenaj) {

angrenaj = startAngrenaj;

cadenta = startCadenta;

viteza = startViteza;

}

public void setCadenta(int valoareNoua) {

cadenta = valoareNoua;

}

public void setAngregaj(int valoareNoua) {

angrenaj = valoareNoua;

}

public void aplicaFrina(int decrementare) {

viteza-= decrementare;

}

public void maresteViteza(int incrementare) {

viteza += incrementare;

}}

O declarație de clasă pentru o clasă BicicletaMunte care este o subclasă de Bicicleta ar putea arăta astfel:

public class BicicletaMunte extends Bicicleta{

public int scaunGreutate;

public BicicletaMunte(int startGreuatate, int startCadenta, int startViteza, int startAngrenaj) {

super(startCadenta, startViteza, startAngrenaj);

scaunGreutate = startGreuatate;

}

public void setGreutate(int valoareNoua) {

scaunGreutate = valoareNoua;

}

}

BicicletaMunte moștenește toți membri clasei Bicicleta, dar în același timp adaugă câmpul scaunGreutate și o metodă pentru a-i seta valoarea.

Rețineți!

1. O subclasă moștenește toți membrii public și protected ai superclasei, indiferent de pachetul în care se află subclasa. 
2. Dacă subclasa se află în același pachet ca și părintele său, moștenește și membrii impliciți ai părintelui, adică cei care nu au nici un modificator de acces specificat. 
3. Puteți folosi membrii moșteniți așa cum sunt, îi puteți înlocui, îi puteți ascunde sau îi puteți completa cu membri noi:
4. Câmpurile moștenite pot fi utilizate direct, la fel ca orice alte câmpuri.
5. Puteți declara un câmp din subclasă cu același nume cu cel din superclasă, astfel ascunzându-l. (NU este recomandat).
6. Puteți declara câmpuri noi în subclasă care nu sunt în superclasă.
7. Metodele moștenite pot fi utilizate direct așa cum sunt.
8. Puteți scrie o nouă metodă de instanță în subclasă care are aceeași semnătură cu cea din superclasă, suprascriind-o astfel (overriding).
9. Puteți scrie o nouă metodă statică în subclasă care are aceeași semnătură cu cea din superclasă, ascunzând-o astfel.
10. Puteți declara metode noi în subclasă care nu sunt în superclasă.
11. Puteți scrie un constructor de subclasă care invocă constructorul superclasei, fie implicit, fie folosind cuvântul cheie super.
12. Nu puteți moșteni membrii privați ai clasei părinte. Totuși, dacă superclasa are metode public sau protected pentru accesarea câmpurilor sale private, acestea pot fi folosite și de subclasă.

În cadrul moștenirii poate fi folosită variabila predefinită super în următoarele cazuri:
1. pentru a referi o variabilă din clasa părinte: super.<nume_variabila>

class ClasaParinte{

int num=100;

}

class Subclasa extends ClasaParinte{

int num=110;

void printNumber(){

System.out.println(super.num);

}

public static void main(String args[]){

Subclasa obj= new Subclasa ();

obj.printNumber();

}}

Atenție!
În cadrul moștenirii, o subclasă poate avea câmpuri cu același nume ca și clasa părinte. În acest caz, câmpul din clasa părinte este "ascuns" în favoarea câmpului cu același nume din subclasă. În codul de mai sus, subclasa Subclasa definește un câmp num care ascunde câmpul cu același nume din clasa părinte ClasaParinte. În metoda printNumber(), se folosește super.num pentru a accesa câmpul num din clasa părinte, care este ascuns în subclasă.

Dacă omitem super.num prioritate va avea variabila din clasa copil:

class ClasaParinte{

int num=100;

}

class Subclasa extends ClasaParinte{

int num=110;

void printNumber(){

System.out.println(num);

}

public static void main(String args[]){

Subclasa obj= new Subclasa ();

obj.printNumber();

}} 

Este important de reținut că utilizarea ascunderii câmpurilor poate duce la confuzie și este bine să fiți atenți la acest aspect. În mod obișnuit, este recomandat să evitați ascunderea câmpurilor, iar dacă este necesar, să fiți conștienți de acest lucru și să folosiți cu atenție super pentru a accesa câmpurile din clasa părinte.

2. pentru a forța apelarea unei metode din cadrul unei clase părinte: 

super.<method_name>

3. pentru apelarea constructorului clasei părinte. Constructorii nu sunt membri, deci nu sunt moșteniți de subclase, dar constructorul superclasei poate fi invocat din subclasă folosind apelul: super([lista_argumente])

Exemplu: 

class Persoanaa{

protected String nume, prenume;

protected int virsta;

Persoanaa (String nume, String prenume, int virsta){

this.nume = nume;

this.prenume = prenume;

this.virsta = virsta;

}

void detalii() {

System.out.print("Nume "+nume+" \nPrenume "+ prenume+" \nVirsta "+virsta);

}}

class Elev extends Persoanaa{

private String adresa;

private double media;

Elev(String nume, String prenume, int virsta, String adresa, double media){

super(nume, prenume, virsta);

this.adresa = adresa;

this.media = media;

}

void detalii() {

super.detalii();

System.out.println(" \nAdresa "+adresa+" \nMedia "+ media);

}}

class Test_mostenire {

public static void main(String[] args) {

Elev e1 = new Elev("Creanga", "Ion", 16, "str. Sarmizegetusa 48", 10);

e1.detalii();

}}

Rețineți !

1. Apelul super() trebuie să fie prima instrucțiune din corpul constructorului subclasei.
2. Dacă constructorul subclasei nu va invoca explicit constructorul superclasei, compilatorul Java va însera automat un apel la constructorul clasei fără parametri.
3. Dacă superclasa nu are constructor fără argumente veți obține eroare de compilare.
4. O clasă declarată final nu poate fi extinsă.

Importanța moștenirii:
1. Moștenirea permite dezvoltatorilor să reutilizeze codul deja scris într-o clasă de bază, fără a-l rescrie în mod repetat în clasele derivate. Acest lucru duce la o eficiență sporită în dezvoltarea software-ului, deoarece codul poate fi scris și testat o singură dată.
2. Moștenirea permite extinderea funcționalității claselor de bază prin adăugarea de metode sau atribute noi în clasele derivate. Astfel, este ușor să adăugați funcționalități noi fără a afecta funcționalitatea existentă.
3. Moștenirea contribuie la organizarea și structurarea codului. Clasele de bază pot reprezenta concepte generale sau abstracte, iar clasele derivate pot să ofere implementări specifice sau detaliate ale acestor concepte.
4. Moștenirea facilitează implementarea polimorfismului, unde obiecte de tipuri diferite pot fi tratați în mod uniform. Acest lucru duce la o mai mare flexibilitate și modularitate în proiectare.
5. Prin intermediul moștenirii, modificările într-o clasă de bază pot avea impact în toate clasele derivate. Astfel, întreținerea și actualizarea codului pot fi mai ușoare, deoarece modificările trebuie făcute doar într-un singur loc.
6. Moștenirea reflectă relații de tip "este-un" între clase. De exemplu, dacă avem o clasă de bază "Animal" și o clasă derivată "Câine", putem spune că "Câinele este un Animal". 

În ansamblu, moștenirea în programare contribuie la creșterea eficienței, flexibilității și ușurinței în dezvoltarea și întreținerea software-ului. Dar...moștenirea o folosim doar când există o relație logică reală „este un”. 

Mulți începători o folosesc forțat, când de fapt ar fi mai corectă alte tipuri de relații despre care noi vom discuta. În proiecte reale, folosirea abuzivă a moștenirii duce deseori la ierarhii rigide și greu de întreținut.

Știați că...
Java 17 introduce câteva funcții noi și îmbunătățiri menite să îmbunătățească lizibilitatea codului, mentenața și securitatea? 

Una dintre cele mai notabile completări la Java 17 este introducerea claselor sealed care oferă mai mult control asupra ierarhiilor de clasă și ajută la aplicarea unei încapsulări mai puternice. Prin declararea unei clase ca sealed, dezvoltatorii pot specifica care clase au voie să o extindă. Acest lucru restricționează efectiv subclasele la un set predefinit, prevenind astfel extensiile neautorizate. Însă ... este suficient pentru această lecție .... vom discuta în altă postare această facilitate a limbajului. 

Dar dacă nu aveți răbdare ... 😍 ...pentru mai multe detalii accesați aici 👉 https://websparrow.org/java/java-17-sealed-classes 

Succes!

❤️

Relații între obiecte Java

Din definiția Programării Orientate spre Obiecte cunoaștem că acesta este un stil de programare în care programele sunt organizate ca şi colecții de obiecte ce cooperează între ele pentru a realiza funcțiile aplicației. Acestea obiecte cooperează între ele prin intermediul unor relații stabilite de programator.

Există mai multe tipuri de relații între obiecte, iar câteva dintre cele comune sunt:

1. Moștenire. Există între o superclasă și o subclasă, este tipul de relație ”is a” sau ”este un/o”. De exemplu: Angajatul este o Persoana, Ciinele este un Animal, SefDepartament este un Angajat.

Exemplu:

class Angajat{
private String nume;
private String adresa;
private int oreLucrate;

public Angajat(String nume, String adresa, int oreLucrate) {
this.nume = nume;
this.oreLucrate = oreLucrate;
this.adresa = adresa;
}
String getNume(){return nume;}
public void setNume(String nume) { this.nume = nume; }

String getAdresa(){return adresa;}
public void setAdresa(String adresa) { this.adresa = adresa; }

public void setOreLucrate(int oreLucrate) { this.oreLucrate = oreLucrate; }
int getOre(){return oreLucrate;}

public int salariu() { return oreLucrate*20; }
}

class SefDepartament extends Angajat {
public SefDepartament(String nume, String adresa, int oreLucrate) {
super(nume, adresa,oreLucrate); }
public int salariuSef() { return salariu()+1000; }
}

class Test{
public static void main(String[] args) {
System.out.println("---------------------------------------------------");
SefDepartament s = new SefDepartament("Decebal Dumitru", "or. Chisinau", 20);
System.out.println(s.getNume() + " "+ s.getAdresa()+" "+s.getOre()+" "+s.salariuSef());
System.out.println("---------------------------------------------------");
Angajat a = new Angajat("Musteata Victoria", "or. Chisinau", 20);
System.out.println(a.getNume() + " "+ a.getAdresa()+" "+a.getOre()+" "+a.salariu());
}}

2. Agregare. Există între două clase în care nu este relație de moștenire, este tipul de relație ”has a” sau ”are un /o”. 

Are la bază următorul principiu: o clasă A, face referire la unul sau mai multe obiecte ale unei alte clase B, o modificare produsă în clasa A nu afectează existența instanțelor clasei B. 

Un exemplu de astfel de relație servește relația între clasele Universitate și Student. O universitate poate avea mai mulți studenți, dar studenții pot exista și în afara universității. Un alt exemplu sunt clasele Proiect și MembruEchipa. Deși membrii echipei sunt asociați cu proiectul, aceștia pot exista independent și pot face parte din alte proiecte sau activități. 

Deci o astfel de interacțiune între obiectele unei clase o numim relație de agregare în contextul domeniului IT.

Exemplu:
class Universitate {

private String denumire;
private Student s;

public Universitate (String denumire, Student l) {
this.denumire = denumire;
s = l;
}

public void afiseazaDetalii(){
System.out.println("Denumirea universitatii: "+denumire);
System.out.println("Elevi: ");
System.out.println(s.getNume() + " " + s.getGrupa());
}}

class Student {
private String nume;
private String grupa;

public String getNume() {return nume; }
public void setNume(String nume){ this.nume = nume; }

public String getGrupa() { return grupa;}
public void setGrupa(String grupa){ this.grupa = grupa; }

public Student(String nume, String grupa) {
this.nume = nume;
this.grupa = grupa;
}}

class Test{
public static void main(String[] args) {
Student x = new Student("Victoria","I5413");
Universitate p = new Universitate ("Digitalizare", x);
p.afiseazaDetalii();
}}

Exemplu:
class Universitate {
private String denumire;
private Student [] lista = new Student[2];

public Universitate (String denumire, Student [] l) {
this.denumire = denumire;
lista = l;
}

public void afiseazaDetalii(){
System.out.println("Denumirea universitatii >>>> "+denumire);
System.out.println("Are elevii: ");
for (int i=0; i<lista.length; i++)
System.out.println(lista[i].getNume() + " " + lista[i].getGrupa()); }
}

class Student {
private String nume;
private String grupa;

public String getNume() {return nume; }
public void setNume(String nume) {
this.nume = nume;
}

public String getGrupa() { return grupa;}
public void setGrupa(String grupa) {
this.grupa = grupa;
}

public Student(String nume, String grupa) {
this.nume = nume;
this.grupa = grupa;
}}

class Test{
public static void main(String[] args) {
Student [] lista = new Student[2];
lista[0] = new Student("Victoria","I5413");
lista[1] = new Student("Mihai","I5412");

Universitate p = new Universitate ("Digitalizare", lista);
p.afiseazaDetalii();
}}

3. Compoziție. Similară agregării, dar cu o legătură mai strânsă. O clasă A este compusă din unul sau mai multe obiecte ale unei alte clase B. Dacă clasa A încetează să existe, și clasa B încetează, de asemenea, să existe. Un exemplu de astfel de relație este:
- relația între clasele Casa și Dormitor, dormitorul nu există separat, el face parte dintr-o casă, respectiv dacă dispare casa nu există nici dormitorul.
- relația dintre clasele Laptop și Procesor. Acest component, procesorul, nu există independent de laptop, indicând astfel o relație de compoziție.
- relația între clasele Masina și Motor. Mașina are un motor, cu alte cuvinte motorul este o componentă a mașinii. Dacă mașina va fi distrusă, motorul va fi distrus la fel. Ciclul de viață pentru obiectul Motor este dependent total de ciclul de viață al obiectului Masina:

class Motor {
private String tip;
private int caiPutere;

Motor(String tip, int caiPutere) {
this.tip = tip;
this.caiPutere = caiPutere;
}

public String getTip() { return tip; }

public void setTip(String tip){this.tip = tip; }

public int getPutere() {return caiPutere; }
public void setPutere(int caiPutere){
this.caiPutere = caiPutere;
}}

class Masina {
private String nume;
private Motor motor;

public Masina(String nume) {
this.nume= nume;
this.motor = new Motor("Motorina", 300);
}
public String getNume() { return nume; }
public Motor getMotor() { return motor; }
}

class TestMasina{
public static void main(String[] args) {
Masina masina = new Masina("BMW");

System.out.println("Denumire masina: " +masina .getNume()+ "\n" +"Tip motor: " +masina.getMotor().getTip()+ "\n" + "Cai putere: " +masina.getMotor().getPutere());
}}

Următorul tabel prezintă diferențele între cele trei tipuri de relații între obiecte în context POO:

Caracteristică	Agregare	Compoziție	Moștenire
Definiție	O relație între două clase în care unul dintre obiecte este parte a altuia, dar poate exista independent.	O relație între două clase în care un obiect este format din alt obiect și nu poate exista independent.	O relație între două clase în care o clasă derivată (subclasă) preia caracteristicile și comportamentul unei clase de bază (superclasă).
Dependența ciclului de viață	Obiectul "parte" poate exista independent de obiectul "întreg".	Obiectul "parte" este de obicei creat și distrus împreună cu obiectul "întreg".	O subclasă poate exista independent de superclasă, dar se bazează pe moștenire pentru a împărți caracteristicile superclasei.
Reprezentare	O clasă poate conține o referință la altă clasă, dar fără a controla durata de viață a obiectelor asociate.	O clasă conține direct un alt obiect și controlează durata de viață a obiectelor asociate.	Subclasă extinde sau specializează superclasă, moștenind și adăugând funcționalități noi.
Flexibilitate	Mai flexibilă, deoarece obiectul "parte" poate exista independent și poate fi partajat între mai multe obiecte "întreg".	Mai rigidă, deoarece obiectul "parte" este strâns legat de obiectul "întreg" și nu poate fi partajat ușor între alte obiecte.	Oferă extensibilitate prin adăugarea și modificarea funcționalității în subclasă, dar poate duce la o dependență puternică între subclasă și superclasă.
Exemplu	O universitate are mulți studenți.	Un calculator are o placă de bază, ce are componente precum procesor, memorie etc.	O clasă "Cercetator" derivată dintr-o clasă "Angajat", moștenind atribuțiile și metodele comune angajaților.

Aceste relații sunt foarte importante în programarea orientată pe obiect pentru a crea structuri flexibile, ușor de înțeles și de întreținut. Este important să se adapteze aceste concepte la contextul specific al aplicației sau sistemului pe care îl dezvoltați. Ele facilitează modularitatea, reutilizarea codului și gestionarea complexității în dezvoltarea software-ului.

Succes!

❤️