...
← Blog Lecții programare java

Compoziția în Java: relația has-a explicată cu exemple de cod

Sigla Java, ilustrație pentru lecția despre compoziția în Java

Compoziția în Java înseamnă să construiești o clasă din alte obiecte, ținute ca atribute, în loc să moștenești comportamentul de la o clasă părinte. Relația se descrie prin „are un” (has-a): o comandă are o adresă de livrare și are mai multe linii de produse. Clasa mare deleagă munca obiectelor din interiorul ei.

În lecția asta construiești pas cu pas o comandă dintr-un magazin online, vezi cum injectezi dependențe prin constructor, cum protejezi listele interne, ce diferență e între compoziție și agregare și de ce mulți programatori preferă compoziția în locul moștenirii.

Ce este compoziția în Java?

Compoziția este relația în care un obiect conține alte obiecte ca părți ale lui și le folosește ca să își facă treaba. Ai folosit-o deja fără să îi spui așa: orice clasă cu un atribut de tip String sau ArrayList e compusă din alte obiecte. Alături de moștenire și polimorfism, e una dintre uneltele de bază ale programării orientate pe obiect.

Un exemplu din viața reală: o mașină are un motor, patru roți și un sistem de frânare. Nu spui că mașina „este un” motor. Spui că „are un” motor. Motorul e o piesă separată, cu responsabilitatea lui, iar mașina îi cere să pornească atunci când pui contactul.

Testul simplu, pe care îl vei folosi mereu: dacă propoziția „X are un Y” sună corect, ai compoziție. Dacă „X este un Y” sună corect, poate fi moștenire. „Comanda are o adresă” e corect. „Comanda este o adresă” nu are sens.

Cum arată compoziția în cod?

În cod, compoziția înseamnă un atribut de tipul altei clase, inițializat de obicei în constructor. Pornim de la două clase mici, fiecare cu o singură responsabilitate:

public class Adresa {
    private final String oras;
    private final String strada;

    public Adresa(String oras, String strada) {
        this.oras = oras;
        this.strada = strada;
    }

    @Override
    public String toString() {
        return strada + ", " + oras;
    }
}

public class LinieComanda {
    private final String produs;
    private final int cantitate;
    private final double pretUnitar;

    public LinieComanda(String produs, int cantitate, double pretUnitar) {
        if (cantitate <= 0) {
            throw new IllegalArgumentException("Cantitatea trebuie să fie pozitivă");
        }
        this.produs = produs;
        this.cantitate = cantitate;
        this.pretUnitar = pretUnitar;
    }

    public double subtotal() {
        return cantitate * pretUnitar;
    }
}

Acum clasa Comanda le combină:

public class Comanda {
    private final String client;
    private final Adresa adresaLivrare;                         // are o adresă
    private final List<LinieComanda> linii = new ArrayList<>();  // are mai multe linii

    public Comanda(String client, Adresa adresaLivrare) {
        this.client = client;
        this.adresaLivrare = adresaLivrare;
    }

    public void adaugaProdus(String produs, int cantitate, double pretUnitar) {
        linii.add(new LinieComanda(produs, cantitate, pretUnitar));
    }

    public double total() {
        double total = 0;
        for (LinieComanda linie : linii) {
            total += linie.subtotal();   // delegare
        }
        return total;
    }
}

Comanda c = new Comanda("Ana Pop", new Adresa("Cluj-Napoca", "Str. Memorandumului 10"));
c.adaugaProdus("Carte Java", 2, 59.90);
c.adaugaProdus("Cană", 1, 25.00);
System.out.println(c.total());   // 144.8

Uită-te la metoda total(). Comanda nu știe cum se calculează subtotalul unei linii, ci îl cere fiecărei linii. Asta se numește delegare: obiectul mare dă mai departe o sarcină obiectului care știe s-o facă. Dacă mâine adaugi reduceri pe linie, modifici doar LinieComanda, iar Comanda rămâne neatinsă.

Compoziție sau moștenire: ce alegi?

Alege compoziția când relația e „are un” sau când vrei să schimbi o piesă fără să atingi restul, și moștenirea doar când relația e cu adevărat „este un” și clasa copil poate înlocui oricând părintele. Recomandarea „preferă compoziția în locul moștenirii” apare în majoritatea cărților despre design orientat pe obiecte, pentru că păstrează clasele mai independente.

CriteriuCompozițieMoștenire
Relația„are un” (has-a)„este un” (is-a)
Cum o scriiatribut de tipul altei claseextends
Cât de legate sunt claselepuțin, comunică prin metode publicemult, copilul depinde de detaliile părintelui
Poți schimba piesa la rulare?da, primești alt obiect în constructornu, ierarhia e fixată la compilare
Câte surse de comportamentoricâte obiecteo singură clasă părinte
ExempluComanda are o AdresăContEconomii este un ContBancar

O greșeală frecventă e moștenirea folosită doar ca să refolosești cod. Dacă scrii class Comanda extends ArrayList<LinieComanda> ca să ai gata metoda add, comanda primește și clear(), remove() și alte zeci de metode care n-au ce căuta acolo. Cu o listă privată în interior, expui doar ce vrei.

Cum injectezi dependențele prin constructor?

Injectarea prin constructor înseamnă că o clasă primește obiectele de care are nevoie ca parametri, în loc să le creeze singură cu new. Combinată cu o interfață, îți permite să schimbi o piesă fără să modifici clasa care o folosește.

Să zicem că, după confirmarea unei comenzi, clientul primește o notificare. Azi pe email, mâine poate pe SMS:

public interface Notificator {
    void trimite(String destinatar, String mesaj);
}

public class NotificatorEmail implements Notificator {
    @Override
    public void trimite(String destinatar, String mesaj) {
        System.out.println("Email către " + destinatar + ": " + mesaj);
    }
}

public class NotificatorSms implements Notificator {
    @Override
    public void trimite(String destinatar, String mesaj) {
        System.out.println("SMS către " + destinatar + ": " + mesaj);
    }
}

public class ServiciuComenzi {
    private final Notificator notificator;

    public ServiciuComenzi(Notificator notificator) {   // primește piesa din afară
        this.notificator = notificator;
    }

    public void confirma(Comanda comanda, String contact) {
        notificator.trimite(contact, "Comanda ta de " + comanda.total() + " lei a fost confirmată.");
    }
}

new ServiciuComenzi(new NotificatorEmail()).confirma(c, "ana@exemplu.ro");
new ServiciuComenzi(new NotificatorSms()).confirma(c, "0722 000 000");

ServiciuComenzi nu știe și nu îl interesează cum ajunge mesajul la client. Știe doar că are un Notificator, adică un obiect care respectă contractul descris de interfață (vezi și tutorialul Oracle despre interfețe). Dacă ar fi scris în interior new NotificatorEmail(), ar fi fost legat pentru totdeauna de email, iar în teste ar fi trimis emailuri adevărate.

Pe exact acest mecanism se bazează Spring Boot, cel mai folosit framework Java pentru backend: îi descrii ce piese ai, iar el le construiește și le injectează prin constructor. Dacă înțelegi compoziția acum, Spring va părea mult mai puțin magic mai târziu.

Cum protejezi obiectele din interior?

Un obiect compus trebuie să își păstreze controlul asupra pieselor lui, altfel încapsularea se pierde. Problema apare cel mai des la liste. Dacă adaugi un getter care returnează direct lista de linii, oricine poate scrie comanda.getLinii().clear() și golește comanda pe la spate.

Soluția e să returnezi o vedere care nu poate fi modificată:

public List<LinieComanda> getLinii() {
    return Collections.unmodifiableList(linii);
}

Acum cine încearcă getLinii().clear() primește UnsupportedOperationException, iar singura cale de a adăuga produse rămâne metoda adaugaProdus, cu validarea ei. Același lucru e valabil și pentru obiectele interne modificabile: dacă le dai referința în afară, oricine le poate schimba starea. De aceea Adresa din exemplu are atribute final și niciun setter.

Care e diferența dintre compoziție și agregare?

Diferența ține de ciclul de viață al părților. La compoziție, partea nu are sens fără întreg și dispare odată cu el. La agregare, partea există independent și poate fi folosită și de alte obiecte.

  • Compoziție: liniile unei comenzi. O linie „2 × Carte Java” nu înseamnă nimic în afara comenzii ei. De aceea Comanda le creează singură în adaugaProdus.
  • Agregare: profesorul unui curs. Cursul are un profesor, dar profesorul există și fără curs și poate preda la mai multe. Obiectul vine din afară, prin constructor.

În Java, codul arată aproape identic în ambele cazuri: un atribut. Diferența e de design și se vede cel mai clar în diagramele UML, unde compoziția are romb plin, iar agregarea romb gol. Pentru începători, distincția contează mai puțin decât ideea de bază: o clasă bună e construită din piese mici, fiecare cu o singură responsabilitate.

Ce greșeli fac începătorii cu compoziția?

Greșelile de compoziție apar de obicei când clasa mare vrea să facă și treaba pieselor ei.

  1. Moștenire pentru o relație „are un”. Masina extends Motor e greșit. Mașina are un motor.
  2. Toate dependențele create cu new în interior. Clasa devine imposibil de testat separat. Primește-le prin constructor.
  3. Getteri care expun liste modificabile. Returnează Collections.unmodifiableList sau o copie.
  4. Piese fără validare. Dacă LinieComanda acceptă cantitatea 0, comanda va avea linii goale. Validarea stă în clasa care deține datele.
  5. Clasa-coordonator care face totul. Dacă Comanda calculează și TVA-ul, și costul livrării, și trimite emailuri, piesele au doar rol de decor. Mută fiecare calcul în clasa căreia îi aparține.
  6. Copii superficiale. Când copiezi o comandă, copiază și lista (new ArrayList<>(linii)), altfel cele două comenzi vor împărți aceleași linii.

Exercițiu: platforma de cursuri

Construiește o mică platformă prin compoziție. Clasa Lectie are titlu și durată în minute. Clasa Curs are un nume și o listă privată de lecții, o metodă adaugaLectie și o metodă durataTotala(), care adună duratele lecțiilor. Clasa Cursant are un nume și un curs la care e înscris.

În main, creează un curs cu trei lecții, înscrie doi cursanți la același curs și afișează durata totală. Întreabă-te la final: când ștergi un cursant, cursul trebuie să dispară? Răspunsul îți spune dacă relația dintre ei e compoziție sau agregare.

Întrebări frecvente

Ce este compoziția în Java?

Este tehnica prin care o clasă conține alte obiecte ca atribute și le deleagă o parte din muncă. Relația se descrie prin „are un”: o comandă are o adresă și are linii de produse.

Care este diferența dintre compoziție și moștenire?

Compoziția descrie o relație „are un” și leagă clasele prin atribute, iar moștenirea descrie o relație „este un” și le leagă prin extends. Compoziția e mai flexibilă, pentru că poți schimba piesele fără să modifici ierarhia de clase.

Compoziția și agregarea sunt același lucru?

Nu chiar. La compoziție, partea nu există fără întreg, cum sunt liniile unei comenzi. La agregare, partea trăiește independent, cum e profesorul unui curs.

Trebuie să folosesc mereu interfețe la compoziție?

Nu. O clasă poate conține direct un obiect Adresa fără nicio interfață. Interfețele merită folosite când ai sau vei avea mai multe variante ale aceleiași piese, cum sunt notificările pe email și pe SMS.

Este compoziția întotdeauna mai bună decât moștenirea?

Nu. Pentru o relație reală „este un”, în care copilul poate înlocui oricând părintele, moștenirea e potrivită. Compoziția e alegerea implicită mai sigură când nu ești sigur.

Primul pas: desparte o clasă prea mare

Caută în exercițiile tale o clasă cu multe atribute care țin de lucruri diferite, de exemplu un Client cu oras, strada și codPostal. Scoate-le într-o clasă Adresa și lasă clientul să aibă o adresă. E cel mai mic pas de compoziție și îl vei face de sute de ori în proiecte reale.

În cursul de Java construiești clase compuse pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Profu’, tutorele AI din lecții, te ajută când nu știi în ce clasă să pui o metodă. Compoziția și injectarea prin constructor sunt baza pe care se construiește traseul de Java Developer, până la Spring Boot.

Lecția anterioară: static vs non-static în Java. Lecția următoare: moștenirea în Java.

Logo Curs Java Interactiv · 15 lecții gratuite

Curs Java

Programare Java pentru începători: de la sintaxă la OOP și colecții

Începe gratuit

Citește și

Primul tău program e la 5 minute distanță.

Creează-ți contul gratuit și începe primele 15 lecții. Fără card, fără instalări.

Începe gratuit