...
← Blog Lecții programare java

Cum citești diagrame UML: simboluri, relații și cod Java

Sigla Java, ilustrație pentru ghidul despre cum citești diagrame UML

Ca să știi cum citești diagrame UML de clase, ai nevoie de trei lucruri: dreptunghiul unei clase (nume, atribute, metode), simbolurile de vizibilitate (+, -, #) și cele șase tipuri de linii dintre clase (moștenire, implementare, asociere, agregare, compoziție, dependență). Cu ele poți citi aproape orice diagramă de clase pe care o vei întâlni la cursuri, la interviuri sau în documentația unui proiect.

În ghidul de mai jos iei fiecare simbol pe rând, vezi cum se traduce în cod Java și citești, la final, diagrama completă a unui magazin online, pe care o transformi în clase care compilează.

Ce este UML și la ce folosește?

UML (Unified Modeling Language) este un limbaj vizual standard pentru a desena structura și comportamentul unei aplicații. Nu e un limbaj de programare: nu rulează și nu se compilează. E un desen cu reguli fixe, pe care orice programator îl citește la fel, indiferent de limbajul în care lucrează.

Gândește-te la planul unui apartament. Înainte să ridice pereții, constructorul se uită pe plan ca să știe unde sunt camerele și cum se leagă între ele. O diagramă UML face același lucru pentru clase: arată ce clase există, ce conțin și cum se leagă, înainte (sau în loc) să citești mii de linii de cod.

Standardul e întreținut de Object Management Group și conține 14 tipuri de diagrame, descrise în specificația oficială UML. Vestea bună: ca începător în Java ai nevoie aproape doar de diagrama de clase. La final îți spun pe scurt și despre celelalte două pe care le vei mai întâlni.

Cum citești o clasă într-o diagramă UML?

O clasă se desenează ca un dreptunghi împărțit în trei: sus numele clasei, la mijloc atributele, jos metodele. Iată clasa Produs dintr-un magazin online:

+--------------------------------------+
|                Produs                |
+--------------------------------------+
| - nume: String                       |
| - pret: double                       |
| - stoc: int                          |
+--------------------------------------+
| + Produs(nume: String, pret: double) |
| + vinde(bucati: int): void           |
| + estePeStoc(): boolean              |
| + getPret(): double                  |
+--------------------------------------+

Diferența față de Java care îi încurcă pe toți la început: în UML, tipul se scrie după nume, despărțit prin două puncte. - pret: double înseamnă în Java private double pret;. La fel la metode: + vinde(bucati: int): void devine public void vinde(int bucati). Tipul returnat stă la final, după paranteză.

Diagramele nu trebuie să conțină fiecare getter și setter. Multe echipe le lasă deoparte și păstrează doar ce ajută la înțelegerea designului. Dacă nu vezi o metodă în diagramă, nu înseamnă că lipsește din cod.

Ce înseamnă +, -, # și ~ în UML?

Semnul din fața fiecărui atribut sau metode arată vizibilitatea, adică cine îl poate folosi. Fiecare corespunde unui modificator de acces din Java:

Simbol UMLModificator JavaCine îl vede
+publicoricine
-privatedoar clasa însăși
#protectedclasa, subclasele și pachetul
~fără modificator (package-private)clasele din același pachet
text subliniatstaticmembru al clasei, nu al obiectului
text italic sau {abstract}abstractclasă sau metodă fără implementare completă
«interface» deasupra numeluiinterfaceun contract, nu o clasă

Regula pe care o vezi în aproape orice diagramă bine făcută: atributele cu minus, metodele cu plus. E încapsularea desenată, aceeași pe care ai aplicat-o în lecția despre clase și obiecte.

Cum citești relațiile dintre clase?

Liniile dintre dreptunghiuri arată cum se leagă clasele, iar tipul liniei și forma capătului îți spun ce fel de relație e. Acestea sunt cele șase pe care trebuie să le recunoști:

RelațiaCum aratăSe citeșteÎn Java
Moștenire (generalizare)linie plină, triunghi gol spre părinte„este un”extends
Implementare (realizare)linie punctată, triunghi gol spre interfață„respectă contractul”implements
Asocierelinie plină simplă, eventual cu săgeată„cunoaște un” / „lucrează cu”atribut de tipul celeilalte clase
Agregarelinie plină, romb gol lângă întreg„are un”, partea trăiește independentatribut primit din afară
Compozițielinie plină, romb plin lângă întreg„e format din”, partea moare cu întregulatribut creat și ținut de întreg
Dependențălinie punctată, săgeată deschisă„folosește temporar”parametru sau variabilă locală

Moștenirea și implementarea

Triunghiul gol arată mereu spre părinte. Aici greșesc cei mai mulți începători: săgeata pleacă de la copil și ajunge la clasa generală, nu invers.

ContEconomii ──────▷ ContBancar        (ContEconomii extends ContBancar)
PlataCard    ┄┄┄┄┄┄▷ «interface» Plata (PlataCard implements Plata)

Dacă ai citit lecția despre moștenirea în Java, ai deja codul pentru prima linie. A doua e aceeași idee aplicată unei interfețe.

Agregarea și compoziția

Rombul stă mereu lângă clasa care conține, adică lângă întreg. Gol înseamnă agregare, plin înseamnă compoziție.

Comanda ◆────── LinieComanda   (compoziție: liniile nu există fără comandă)
Curs    ◇────── Profesor       (agregare: profesorul există și fără curs)

În Java, ambele devin un atribut. Diferența e de design: la compoziție, întregul își creează și își controlează părțile, așa cum ai văzut în lecția despre compoziția în Java. La agregare, partea vine din afară și poate fi împărțită cu alte obiecte.

Asocierea și dependența

Asocierea e o legătură stabilă, ținută ca atribut, iar dependența e una trecătoare. Dacă Comanda are un atribut client, avem asociere. Dacă Comanda primește un obiect Plata doar ca parametru în metoda plateste() și nu îl păstrează, avem dependență, desenată cu linie punctată.

Săgeata de la capătul unei asocieri arată navigabilitatea: Comanda ──> Client înseamnă că o comandă își cunoaște clientul, dar clientul nu are neapărat o listă de comenzi. O linie fără săgeți înseamnă de obicei că ambele clase se cunosc.

Ce înseamnă 1, 0..1 și * pe o linie UML?

Numerele de la capetele liniilor se numesc multiplicitate și arată câte obiecte de pe o parte se leagă de un obiect de pe cealaltă. Se citesc de la clasa de lângă care stă numărul.

NotațieÎnseamnăExemplu
1exact unulo comandă are exact un client
0..1niciunul sau unulun client are cel mult o adresă de facturare salvată
* sau 0..*oricâte, inclusiv zeroun client are oricâte comenzi
1..*cel puțin unulo comandă are cel puțin o linie
Client 1 ────────── 0..* Comanda

Se citește în ambele direcții: „un client are zero sau mai multe comenzi” și „fiecare comandă aparține exact unui client”. În Java, partea cu * devine aproape mereu o listă: private List<Comanda> comenzi;. Partea cu 1 devine un singur atribut, de obicei setat în constructor, ca să nu poată lipsi.

Cum citești o diagramă UML completă, pas cu pas?

O diagramă mare devine ușor de citit dacă o iei în aceeași ordine de fiecare dată. Iată diagrama simplificată a unui magazin online:

                                «interface»
                                   Plata
                                     △
                                     ┆
                                 PlataCard

Comanda ┄┄┄┄┄┄┄┄> Plata          (folosește o plată doar în plateste())

Client 1 ────────── 0..* Comanda ◆────────── 1..* LinieComanda ──────────> 1 Produs

Pe lângă relații, fiecare dreptunghi are atributele și metodele lui: Client are - nume: String și - email: String; Comanda are - numarComenzi: int (subliniat, deci static), + adaugaProdus(produs: Produs, cantitate: int): void, + total(): double și + plateste(plata: Plata): boolean; LinieComanda are - cantitate: int și + subtotal(): double; Produs are - nume: String și - pret: double.

  1. Găsește clasa centrală. Cea cu cele mai multe linii, aici Comanda. Restul diagramei se citește în jurul ei.
  2. Citește ierarhiile. Triunghiurile goale: PlataCard implementează Plata. Oriunde apare Plata, poți folosi o plată cu cardul.
  3. Citește compozițiile și agregările. Rombul plin: comanda e formată din linii, care dispar odată cu ea.
  4. Citește multiplicitatea. Un client, oricâte comenzi. O comandă, cel puțin o linie. Fiecare linie, exact un produs.
  5. Citește dependențele. Linia punctată spre Plata: comanda folosește o plată doar în metoda plateste.
  6. Abia apoi intră în detalii. Atribute, metode, tipuri, vizibilitate.

Cum transformi o diagramă UML în cod Java?

Fiecare element din diagramă are un corespondent direct în Java, iar dacă le traduci pe rând, obții un schelet de cod care compilează. Iată clasa centrală din diagrama de mai sus:

public class Comanda {
    private static int numarComenzi = 0;                  // subliniat în UML
    private Client client;                                // asociere, multiplicitate 1
    private List<LinieComanda> linii = new ArrayList<>();  // compoziție, 1..*

    public Comanda(Client client) {
        this.client = client;
        numarComenzi++;
    }

    public void adaugaProdus(Produs produs, int cantitate) {
        linii.add(new LinieComanda(produs, cantitate));    // comanda își creează liniile
    }

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

    public boolean plateste(Plata plata) {                // dependență: doar parametru
        return plata.proceseaza(total());
    }
}

public interface Plata {
    boolean proceseaza(double suma);
}

public class PlataCard implements Plata {
    @Override
    public boolean proceseaza(double suma) {
        System.out.println("Plată cu cardul: " + suma + " lei");
        return true;
    }
}

Diagrama nu îți spune totul. Validările (o cantitate negativă, un client fără email), mesajele de eroare și detaliile de implementare le adaugi tu. Diagrama e harta, nu teritoriul.

Ce alte diagrame UML vei mai întâlni?

În afară de diagrama de clase, doar două tipuri apar des în proiectele obișnuite, iar amândouă se citesc mai ușor decât par:

  • Diagrama de secvență arată ordinea apelurilor dintre obiecte în timp. Fiecare obiect are o linie verticală, iar săgețile orizontale sunt apeluri de metode, de sus în jos. Ex.: Client apelează Comanda.plateste(), care apelează Plata.proceseaza(), care returnează true.
  • Diagrama de cazuri de utilizare arată ce poate face fiecare tip de utilizator. Omuleții sunt actorii („Client”, „Administrator”), iar ovalele sunt acțiunile („Plasează comanda”, „Adaugă produs”). Apare des în documentele de analiză și la testare.

Pentru desenat, ai unelte gratuite ca draw.io (diagrams.net) sau PlantUML, care generează diagrama dintr-un text simplu. Multe IDE-uri, inclusiv IntelliJ IDEA, pot genera diagrama de clase direct din codul tău, un mod bun de a verifica dacă ai înțeles relațiile.

Ce greșeli faci când citești diagrame UML?

Greșelile de citire sunt aproape mereu aceleași și vin din simboluri care seamănă între ele.

  1. Citești săgeata de moștenire invers. Triunghiul arată spre părinte, nu spre copil.
  2. Confunzi rombul plin cu cel gol. Plin = compoziție (partea moare cu întregul). Gol = agregare.
  3. Pui rombul la capătul greșit. Rombul stă lângă întreg, nu lângă parte.
  4. Ignori multiplicitatea. 1..* înseamnă că o comandă fără linii e invalidă, deci ai nevoie de validare în cod.
  5. Inversezi numele și tipul. În UML, pret: double, numele întâi. În Java, tipul întâi.
  6. Crezi că orice linie e moștenire. O linie plină fără triunghi e doar o asociere.

Întrebări frecvente

Ce înseamnă UML?

Unified Modeling Language, un limbaj vizual standard pentru descrierea aplicațiilor software. Nu se compilează și nu rulează, ci e o formă comună de desen pentru clase, relații și fluxuri.

Trebuie să cunosc toate diagramele UML?

Nu. Ca începător în Java, diagrama de clase acoperă aproape tot ce ai nevoie. Diagramele de secvență și de cazuri de utilizare le înveți când le întâlnești într-un proiect.

Ce reprezintă rombul negru în UML?

Compoziția: întregul e format din părți care nu există fără el, cum sunt liniile unei comenzi. Rombul stă lângă clasa care conține.

Ce înseamnă 0..* într-o diagramă UML?

Înseamnă „oricâte, inclusiv niciunul”. În Java se traduce de obicei printr-o listă, de exemplu List<Comanda>.

UML este folosit în proiectele reale?

Da, dar mai ales ca schiță, nu ca documentație completă. Echipele desenează diagrame de clase și de secvență ca să discute un design sau să explice o parte complicată, iar întrebările despre UML apar și la interviurile de junior.

Primul pas: desenează-ți propriul exercițiu

Ia ultimul exercițiu cu mai multe clase pe care l-ai scris și desenează-l pe hârtie: dreptunghiuri cu trei secțiuni, semne de vizibilitate, linii cu multiplicitate. Apoi compară desenul cu codul. Dacă nu știi ce linie să pui între două clase, de obicei e semn că relația dintre ele nu e clară nici în cod.

În cursul de Java treci prin toate conceptele din diagramele de clase (moștenire, interfețe, compoziție) pe exerciții verificate automat, iar primele 15 lecții sunt gratuite. Profu’, tutorele AI din lecții, îți explică exercițiul când te blochezi. Pentru drumul complet spre primul job, vezi traseul de Java Developer.

Lecția anterioară: moștenirea în Java. Lecția următoare: polimorfism î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