...
← Blog Programare java

Programare orientată pe obiect (OOP) în Java, cu exemplu complet

Sigla Java, ilustrație pentru articolul despre programarea orientată pe obiect în Java

Programarea orientată pe obiect (OOP sau POO) este un mod de a organiza codul în obiecte care au date proprii și comportamente, construite după un șablon numit clasă. Se sprijină pe patru principii: încapsulare, moștenire, polimorfism și abstractizare. În Java, aproape tot codul e scris așa, de aceea OOP e baza oricărui job de junior.

Mai jos vezi ce înseamnă fiecare principiu, apoi le pui pe toate patru la lucru într-un singur program care rulează: un mic sistem de conturi bancare, explicat bucată cu bucată.

Ce este programarea orientată pe obiect?

Programarea orientată pe obiect înseamnă să modelezi problema ca pe un set de „lucruri” care colaborează, nu ca pe o listă lungă de instrucțiuni. Fiecare lucru e un obiect cu propriile date (atribute) și propriile acțiuni (metode).

Gândește-te la un cont bancar. Are un titular și un sold, adică date. Poți depune bani sau retrage bani, adică acțiuni. Clasa Cont descrie cum arată orice cont; contul Anei și contul lui Ion sunt două obiecte concrete create după acest șablon, fiecare cu soldul lui.

Alternativa e programarea procedurală, în care ai variabile separate și funcții care le modifică. Merge bine pentru programe mici. Când aplicația crește la sute de fișiere, OOP te ajută să știi unde stă fiecare regulă: tot ce ține de un cont stă în clasa Cont.

Care sunt cele 4 principii OOP în Java?

Cele patru principii ale programării orientate pe obiect sunt încapsularea, moștenirea, polimorfismul și abstractizarea. Pe scurt:

PrincipiuCe înseamnăCum arată în JavaLa ce te ajută
Încapsulareascunzi datele și le modifici doar prin metode controlateprivate + metode publicnimeni nu pune un sold negativ din greșeală
Moștenireo clasă preia atributele și metodele alteiaextends, supernu rescrii același cod în mai multe clase
Polimorfismacelași apel se comportă diferit în funcție de obiect@Override, variabilă de tipul părinteluiadaugi tipuri noi fără să schimbi codul existent
Abstractizarearăți doar ce face un obiect, nu cum faceabstract class, interfacecine folosește clasa nu are nevoie de detalii

Exemplu de programare orientată pe obiect în Java

Construim un sistem cu două tipuri de cont: contul curent, cu un comision fix de 2 lei la retragere, și contul de economii, cu un comision de 1%. Soldul e un număr întreg de lei, ca exemplul să rămână simplu; într-o aplicație reală, sumele de bani se țin în BigDecimal.

Clasa de bază: încapsulare și abstractizare

abstract class Cont {
    private final String titular;
    private int sold;

    public Cont(String titular, int soldInitial) {
        this.titular = titular;
        this.sold = soldInitial;
    }

    public void depune(int suma) {
        if (suma <= 0) {
            System.out.println("Suma trebuie să fie pozitivă");
            return;
        }
        sold += suma;
    }

    public boolean retrage(int suma) {
        int total = suma + comision(suma);
        if (total > sold) {
            System.out.println(titular + ": fonduri insuficiente");
            return false;
        }
        sold -= total;
        return true;
    }

    public int getSold() {
        return sold;
    }

    public String getTitular() {
        return titular;
    }

    protected abstract int comision(int suma);
}

Ce se întâmplă aici, pe rând:

  • Încapsularea e în cuvântul private. Câmpul sold nu poate fi modificat din afara clasei. Singurele căi sunt depune și retrage, care verifică regulile: nu depui sume negative, nu retragi mai mult decât ai.
  • Constructorul Cont(...) stabilește valorile de pornire la crearea obiectului. titular e final, deci nu se mai schimbă după aceea.
  • Abstractizarea e în abstract. Clasa spune că orice cont are un comision, dar nu spune cât. Nu poți crea un obiect new Cont(...), ci doar obiecte din clasele concrete de mai jos.

Dacă cineva încearcă totuși să ocolească regulile, compilatorul îl oprește:

cont.sold = -500;
// error: sold has private access in Cont

Clasele copil: moștenire

class ContCurent extends Cont {
    public ContCurent(String titular, int soldInitial) {
        super(titular, soldInitial);
    }

    @Override
    protected int comision(int suma) {
        return 2;
    }
}

class ContEconomii extends Cont {
    public ContEconomii(String titular, int soldInitial) {
        super(titular, soldInitial);
    }

    @Override
    protected int comision(int suma) {
        return suma / 100;
    }
}

extends Cont înseamnă că fiecare clasă copil primește gata făcute titularul, soldul, depune, retrage și getterele. Scrie doar ce o face diferită: comisionul. super(...) apelează constructorul părintelui, ca titularul și soldul să fie setate corect. Despre ce se moștenește și ce nu găsești mai multe în lecția despre moștenirea în Java.

Programul principal: polimorfism

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Cont> conturi = List.of(
                new ContCurent("Ana Pop", 1000),
                new ContEconomii("Ion Marin", 5000)
        );

        for (Cont cont : conturi) {
            cont.retrage(300);
            System.out.println(cont.getTitular() + ": " + cont.getSold() + " lei");
        }
    }
}

Rezultatul:

Ana Pop: 698 lei
Ion Marin: 4697 lei

Asta e polimorfismul. Lista e de tipul Cont, iar bucla apelează același retrage(300) pe fiecare element. Java alege însă, la rulare, metoda comision a clasei reale: 2 lei pentru Ana, 3 lei (1% din 300) pentru Ion. Dacă mâine adaugi un ContStudent fără comision, bucla nu se schimbă deloc. Mai multe exemple sunt în lecția despre polimorfism în Java.

Ca să rulezi exemplul, pune toate cele trei bucăți într-un singur fișier Main.java, cu linia import la început. Doar clasa Main e public, deci fișierul compilează fără probleme.

Clasă abstractă sau interfață: care e diferența?

Ambele servesc abstractizării, dar o clasă abstractă poate avea și date și cod comun, pe când o interfață descrie de obicei doar ce metode trebuie să existe. În exemplul nostru, Cont e clasă abstractă pentru că toate conturile împart soldul și regulile de retragere.

O interfață ar fi potrivită pentru o capacitate pe care o pot avea clase fără legătură între ele, de exemplu Exportabil, implementată și de un cont, și de o factură, și de un raport. O clasă Java poate moșteni o singură clasă, dar poate implementa oricâte interfețe. Explicația oficială a conceptelor, în engleză, e în tutorialul Oracle despre conceptele OOP.

Ce greșeli fac începătorii la OOP?

Cele mai multe probleme vin din faptul că scrii clase, dar continui să gândești procedural. Iată ce vezi cel mai des:

  1. Câmpuri publice peste tot. public int sold; anulează încapsularea: orice cod poate pune orice valoare. Pornește mereu cu private.
  2. Getter și setter pentru orice câmp, din reflex. Un setSold() public face exact ce făcea câmpul public. Oferă metode cu sens (depune, retrage), nu acces brut.
  3. Moștenire unde nu e cazul. Întreabă-te dacă relația e „este un” (un cont de economii este un cont). Dacă e „are un” (o bancă are conturi), folosești compoziția, adică un câmp, nu extends.
  4. O singură clasă uriașă. Dacă o clasă are 30 de metode care fac lucruri diferite, probabil sunt de fapt trei clase.
  5. Uiți @Override. Fără el, o greșeală de tastare în numele metodei creează o metodă nouă, iar polimorfismul nu mai funcționează. Cu el, compilatorul te avertizează.

Exercițiu: adaugă un cont de student

Pornește de la codul de mai sus și creează clasa ContStudent, fără comision la retrageri sub 500 de lei și cu 5 lei comision peste această sumă. Adaug-o în listă cu un sold inițial de 800 de lei și rulează programul.

Dacă ai lucrat corect, nu ai modificat nicio linie din Cont sau din bucla din main, iar programul afișează un al treilea rând cu soldul de 500 de lei. Pentru un pas în plus, adaugă în Cont o metodă transfera(Cont destinatie, int suma) care folosește retrage și depune.

Întrebări frecvente

Care e diferența dintre OOP și POO?

Niciuna. OOP vine din engleză (Object-Oriented Programming), iar POO e traducerea românească (programare orientată pe obiecte). Ambele denumiri apar în facultăți și în anunțurile de angajare.

Ce este o clasă și ce este un obiect?

Clasa e șablonul, iar obiectul e un exemplar concret creat după el. Cont e clasa; contul Anei, creat cu new ContCurent("Ana Pop", 1000), e un obiect. Poți crea oricâte obiecte dintr-o clasă, fiecare cu datele lui.

Se întreabă OOP la interviurile de Java?

Da, aproape mereu. La un interviu de junior te poți aștepta să explici cele patru principii cu exemple proprii, diferența dintre clasă abstractă și interfață și diferența dintre overloading și overriding.

Există OOP și în alte limbaje?

Da. C#, Python, C++, Kotlin, PHP și TypeScript folosesc aceleași idei, cu sintaxă diferită. Dacă înțelegi OOP în Java, care e destul de strict, trecerea la alt limbaj orientat pe obiecte e ușoară.

Cât durează să înțeleg OOP?

Definițiile le înveți într-o zi; să le folosești natural durează câteva săptămâni de exercițiu. Momentul în care „se leagă” vine de obicei la primul proiect cu cinci-șase clase care colaborează.

Primul pas: scrie primele tale clase

Rescrie exemplul de mai sus fără să te uiți la cod, apoi rezolvă exercițiul cu ContStudent. Dacă vrei să înveți OOP pas cu pas, cu exerciții verificate automat, modulul de programare orientată pe obiecte din cursul de Java acoperă clase, încapsulare, moștenire, polimorfism, clase abstracte, interfețe, enum și records, cu proiecte precum o parcare inteligentă. Primele 15 lecții, cu fundamentele limbajului, sunt gratuite. Pentru tabloul complet al etapelor prin care treci, vezi ghidul despre ce înveți într-un curs de programator 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