...
← Blog Lecții programare java

Clase și obiecte în Java: prima ta clasă OOP, pas cu pas

Sigla Java, ilustrație pentru lecția despre clase și obiecte în Java

Clasele și obiectele în Java sunt baza programării orientate pe obiecte (OOP). O clasă este șablonul care descrie ce date are un lucru și ce poate face, iar un obiect este un exemplar concret creat din acel șablon cu new. Clasa Produs descrie orice produs dintr-un magazin, iar laptopul de 3.499 de lei din coș este un obiect.

În lecția asta scrii prima ta clasă completă: atribute, constructor, metode, private cu getteri, toString(), compararea obiectelor cu equals() și o listă de obiecte. Fiecare exemplu rulează așa cum e scris.

Ce este programarea orientată pe obiecte?

Programarea orientată pe obiecte este un mod de a organiza codul în care datele și operațiile pe acele date stau împreună, în același obiect. Până acum ai lucrat cu variabile separate și metode statice. Pentru un magazin online, asta ar însemna trei vectori paraleli: unul cu nume, unul cu prețuri, unul cu stocuri. Dacă ștergi un produs dintr-un vector și uiți de celelalte, datele nu mai corespund.

Cu OOP, fiecare produs devine un obiect care își ține singur numele, prețul și stocul și știe singur să se vândă. Java este construit în jurul acestei idei, iar Spring, Android și aproape orice proiect Java real arată așa. Dacă vrei imaginea de ansamblu a celor patru principii (încapsulare, moștenire, polimorfism, abstractizare), o găsești în articolul despre programarea orientată pe obiect.

Ce este o clasă în Java?

O clasă este o descriere a unui tip de lucru: ce informații are (atribute) și ce acțiuni știe să facă (metode). Clasa nu e un produs anume, ci regula după care se construiesc toate produsele.

public class Produs {
    // atribute: datele fiecărui produs
    private String nume;
    private double pret;
    private int stoc;

    // constructor: rulează la crearea obiectului
    public Produs(String nume, double pret, int stoc) {
        this.nume = nume;
        this.pret = pret;
        this.stoc = stoc;
    }

    // metode: ce știe să facă un produs
    public void vinde(int bucati) {
        if (bucati > stoc) {
            System.out.println("Stoc insuficient pentru " + nume);
            return;
        }
        stoc -= bucati;
    }

    public boolean estePeStoc() {
        return stoc > 0;
    }
}

Atributele sunt variabilele declarate direct în clasă, în afara metodelor. Fiecare obiect primește propria copie a lor. Metodele sunt cele din lecția despre funcții, doar că acum nu mai au static și lucrează cu datele obiectului pe care sunt apelate.

Ce este un obiect în Java și cum îl creezi?

Un obiect este o instanță a unei clase, adică un exemplar concret cu propriile valori. Îl creezi cu operatorul new, care rezervă memorie pentru el și apelează constructorul:

Produs laptop = new Produs("Laptop", 3499.99, 5);
Produs mouse = new Produs("Mouse", 89.5, 0);

laptop.vinde(2);
System.out.println(laptop.estePeStoc());  // true, mai are 3
System.out.println(mouse.estePeStoc());   // false
mouse.vinde(1);                           // Stoc insuficient pentru Mouse

Ambele obiecte vin din aceeași clasă, dar au stări independente. Când vinzi două laptopuri, stocul mouse-ului nu se schimbă. Punctul dintre obiect și metodă (laptop.vinde(2)) înseamnă „cere-i obiectului laptop să execute metoda vinde”.

Care e diferența dintre clasă și obiect?

Clasa e planul, obiectul e construcția. Din planul unui apartament poți construi 40 de apartamente identice ca structură, dar fiecare are alți locatari și altă mobilă.

CriteriuClasăObiect
Ce esteșablonul, descrierea tipuluiun exemplar concret
Câte existăuna singură în programoricâte, create cu new
Când aparela compilare, în codul sursăîn timpul rulării, în memorie
Exempluclass Produsnew Produs("Laptop", 3499.99, 5)
Are valori?nu, doar declară atributeleda, fiecare obiect are ale lui

Ce face constructorul și cuvântul this?

Constructorul este codul care rulează o singură dată, în momentul în care creezi obiectul, și îi dă valorile de pornire. Are același nume ca clasa și nu are tip returnat, nici măcar void.

În constructorul din exemplu, parametrul se numește tot nume, ca atributul. this.nume înseamnă „atributul obiectului curent”, iar nume simplu înseamnă parametrul. Fără this, ai scrie nume = nume, adică parametrul s-ar atribui lui însuși, iar atributul ar rămâne null.

Constructorul e și locul în care oprești datele greșite. Un produs cu preț negativ nu are sens, așa că îl refuzi de la început:

public Produs(String nume, double pret, int stoc) {
    if (pret < 0) {
        throw new IllegalArgumentException("Prețul nu poate fi negativ");
    }
    this.nume = nume;
    this.pret = pret;
    this.stoc = stoc;
}

Constructorii au destule reguli (constructorul implicit, supraîncărcarea, this()) încât au o lecție separată, chiar următoarea din serie.

De ce atributele sunt private? Încapsularea pe scurt

Atributele sunt private ca să nu poată fi modificate din afara clasei fără control. Asta se numește încapsulare: obiectul își protejează datele și le schimbă doar prin metodele lui.

Dacă stoc ar fi public, oricine ar putea scrie laptop.stoc = -50 și magazinul ar avea un stoc negativ. Cu private, singura cale de a scădea stocul e metoda vinde, care verifică întâi dacă sunt destule bucăți. Pentru citire adaugi getteri:

public String getNume() { return nume; }
public double getPret() { return pret; }
public int getStoc() { return stoc; }

Nu pune automat câte un setter pentru fiecare atribut. Un setStoc(int) ar ocoli exact verificarea din vinde. Adaugă setteri doar pentru valorile care chiar au voie să se schimbe din afară, și pune validare în ei.

Cum afișezi un obiect cu toString()?

Metoda toString() decide ce text apare când afișezi obiectul. Fără ea, System.out.println(laptop) afișează ceva de genul Produs@1b6d3586, adică numele clasei și un cod intern, de care nu te ajuți cu nimic.

@Override
public String toString() {
    return nume + " (" + pret + " lei, stoc " + stoc + ")";
}

System.out.println(laptop);  // Laptop (3499.99 lei, stoc 3)

Adnotarea @Override îi spune compilatorului că rescrii o metodă moștenită de la clasa Object, din care provin toate clasele Java. Dacă greșești numele (de exemplu tostring), compilatorul te avertizează imediat.

Cum compari două obiecte: == sau equals()?

Operatorul == verifică dacă două variabile arată spre același obiect din memorie, iar equals() verifică dacă două obiecte au același conținut, după regula pe care o scrii tu. Aici apare una dintre cele mai frecvente confuzii de început.

O variabilă de tip obiect nu conține obiectul, ci o referință, adică adresa lui. Când scrii Produs a = laptop;, nu creezi un laptop nou, ci o a doua etichetă pe același obiect. Dacă vinzi prin a, scade și stocul văzut prin laptop.

Produs p1 = new Produs("Cană", 25.0, 10);
Produs p2 = new Produs("Cană", 25.0, 10);

System.out.println(p1 == p2);       // false: două obiecte diferite
System.out.println(p1.equals(p2));  // true, dacă ai scris equals()

Ca să meargă al doilea rând, clasa trebuie să suprascrie equals() și, împreună cu el, hashCode():

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Produs)) return false;
    Produs altul = (Produs) o;
    return nume.equals(altul.nume) && pret == altul.pret;
}

@Override
public int hashCode() {
    return java.util.Objects.hash(nume, pret);
}

Regula: dacă două obiecte sunt egale după equals(), trebuie să aibă același hashCode(). Altfel, colecții ca HashSet și HashMap nu le mai găsesc corect. Contractul complet e descris în documentația oficială a clasei Object.

Cum lucrezi cu o listă de obiecte?

Cele mai multe aplicații țin obiectele într-o listă și le parcurg cu o buclă. Combini aici tot ce ai învățat în lecția despre ArrayList cu metodele propriei clase:

List<Produs> cos = new ArrayList<>();
cos.add(laptop);
cos.add(new Produs("Căști", 199.0, 12));
cos.add(mouse);

double total = 0;
for (Produs p : cos) {
    if (p.estePeStoc()) {
        total += p.getPret();
    }
}
System.out.println("Total: " + total + " lei");  // Total: 3698.99 lei

Bucla nu știe nimic despre cum e calculat stocul. Întreabă doar fiecare produs „ești pe stoc?” și primește răspunsul. Asta e diferența față de codul cu vectori paraleli: logica stă în clasă, nu împrăștiată prin main.

Ce greșeli fac începătorii cu clase și obiecte?

Primele clase scrise de cei mai mulți începători au aceleași probleme, iar toate se repară ușor odată ce le recunoști.

  1. Atribute publice. Oricine le poate modifica, iar obiectul ajunge în stări imposibile (stoc negativ, nume gol). Fă-le private.
  2. Constructorul acceptă orice. Validează în constructor, ca obiectul să fie corect încă de la creare.
  3. Uiți de new. Produs p; doar declară variabila. Până nu scrii p = new Produs(...), nu există niciun obiect.
  4. Apelezi metode pe null. O variabilă de tip obiect fără valoare e null, iar p.getNume() aruncă NullPointerException.
  5. Compari obiecte cu ==. Inclusiv String-urile: pentru conținut folosește mereu equals().
  6. Atribute static pentru date individuale. Un static int stoc ar fi comun tuturor produselor. Diferența o explică pe larg lecția despre static vs non-static.
  7. O clasă care face totul. Dacă Produs trimite și emailuri și generează facturi PDF, împarte-o. O clasă bună are o singură responsabilitate.

Atributele neinițializate primesc valori implicite: 0 pentru numere, false pentru boolean și null pentru obiecte și String. Variabilele locale din metode nu primesc nimic și trebuie inițializate înainte de folosire.

Exercițiu: clasa Cursant

Scrie o clasă Cursant cu atributele private nume, email și lectiiTerminate. Constructorul primește numele și emailul și refuză un email fără @. Adaugă metoda terminaLectie(), care crește contorul cu 1, metoda progres(int totalLectii), care returnează procentul parcurs, și un toString().

În main, creează trei cursanți, pune-i într-un ArrayList, termină câteva lecții pentru fiecare și afișează-l pe cel cu progresul cel mai mare.

Întrebări frecvente

Care este diferența dintre o clasă și un obiect în Java?

Clasa este șablonul care descrie atributele și metodele, iar obiectul este un exemplar concret creat din ea cu new. Dintr-o clasă poți crea oricâte obiecte, fiecare cu propriile valori.

Este obligatoriu să scriu un constructor?

Nu. Dacă nu scrii niciunul, Java adaugă automat un constructor fără parametri. De îndată ce scrii tu un constructor, cel automat dispare.

Orice atribut are nevoie de getter și setter?

Nu. Adaugi getter doar pentru ce trebuie citit din afară și setter doar pentru ce are voie să se schimbe. Un setter fără validare anulează practic avantajul lui private.

Ce face operatorul new?

Rezervă memorie pentru un obiect nou, apelează constructorul și returnează referința spre obiect. Referința o salvezi într-o variabilă ca să lucrezi mai departe cu obiectul.

De ce două obiecte cu aceleași valori nu sunt egale cu ==?

Pentru că == compară adresele din memorie, iar două obiecte create separat au adrese diferite. Pentru conținut folosești equals(), pe care îl suprascrii în clasa ta.

Primul pas: transformă un program vechi în clase

Ia un exercițiu rezolvat mai devreme cu vectori paraleli (nume și note, produse și prețuri) și rescrie-l cu o clasă. Vei vedea cât de mult se scurtează main și cât de greu devine să strici datele din greșeală.

În cursul de Java lucrezi cu clase și obiecte pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Dacă te blochezi la equals() sau la referințe, Profu’, tutorele AI din lecții, îți explică exercițiul. Programarea orientată pe obiecte e și baza traseului de Java Developer.

Lecția anterioară: recursivitatea în Java. Lecția următoare: constructorul î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