
Polimorfismul în Java este capacitatea unui obiect de a fi folosit prin tipul părintelui sau al unei interfețe, în timp ce comportamentul real vine din clasa lui concretă. Apelezi aceeași metodă, livrare.cost(), pe obiecte diferite și fiecare răspunde în felul lui: curierul calculează după greutate, punctul de ridicare are preț fix. Java alege versiunea corectă abia în timpul rulării.
Dacă vrei să înveți practic, curs Java pentru începători are primele lecții gratuite, cu exerciții verificate direct în browser.
În lecția asta vezi polimorfismul pe un exemplu de livrări dintr-un magazin online: suprascrierea, upcasting și downcasting, liste polimorfice, interfețe, clase abstracte și diferența dintre polimorfismul static și cel dinamic.
Ce este polimorfismul în Java?
Polimorfismul („mai multe forme”) înseamnă că o singură referință, de un tip general, poate arăta spre obiecte de tipuri diferite, iar fiecare obiect execută propria versiune a metodei apelate. Codul care folosește obiectele nu trebuie să știe ce tip concret are în față.
Gândește-te la butonul „Plasează comanda” dintr-un magazin online. Clientul alege livrare prin curier, la un punct de ridicare sau expres în aceeași zi. Codul care calculează totalul coșului nu are nevoie de trei ramuri if. Îi cere livrării costul, iar livrarea știe singură cum să îl calculeze.
Polimorfismul se sprijină pe moștenire și pe interfețe, deci dacă lecția despre moștenirea în Java nu îți e încă la îndemână, merită recitită înainte.
Cum arată polimorfismul într-un exemplu simplu?
Pornești de la o clasă părinte care declară o metodă, iar fiecare clasă copil o suprascrie cu propria logică. Aici, clasa părinte e abstractă: nu are sens o „livrare” generică, ci doar livrări concrete.
public abstract class Livrare {
protected final double greutateKg;
protected Livrare(double greutateKg) {
this.greutateKg = greutateKg;
}
public abstract double cost(); // fiecare livrare își calculează costul
public String descriere() {
return getClass().getSimpleName() + ", " + greutateKg + " kg: " + cost() + " lei";
}
}
public class LivrareCurier extends Livrare {
public LivrareCurier(double greutateKg) { super(greutateKg); }
@Override
public double cost() {
return 20 + 2 * greutateKg;
}
}
public class LivrarePunctRidicare extends Livrare {
public LivrarePunctRidicare(double greutateKg) { super(greutateKg); }
@Override
public double cost() {
return 12;
}
}
public class LivrareExpres extends LivrareCurier {
public LivrareExpres(double greutateKg) { super(greutateKg); }
@Override
public double cost() {
return super.cost() + 15; // costul curierului plus taxa de urgență
}
public String intervalOrar() {
return "în aceeași zi, 18:00–22:00";
}
} Și partea care contează, codul care le folosește:
List<Livrare> livrari = List.of(
new LivrareCurier(3),
new LivrarePunctRidicare(3),
new LivrareExpres(3)
);
for (Livrare l : livrari) {
System.out.println(l.descriere());
}
// LivrareCurier, 3.0 kg: 26.0 lei
// LivrarePunctRidicare, 3.0 kg: 12.0 lei
// LivrareExpres, 3.0 kg: 41.0 lei Bucla vede doar Livrare. Nu are niciun if, niciun instanceof. Chiar și metoda descriere(), scrisă o singură dată în părinte, apelează cost() și primește versiunea corectă pentru fiecare obiect. Dacă mâine apare livrarea cu drona, scrii o clasă nouă, iar bucla rămâne neschimbată.
Care e diferența dintre polimorfismul static și cel dinamic?
Polimorfismul static se decide la compilare și vine din supraîncărcare (overloading), iar polimorfismul dinamic se decide la rulare și vine din suprascriere (overriding). Când programatorii spun simplu „polimorfism”, se referă aproape mereu la cel dinamic.
| Criteriu | Static (compile-time) | Dinamic (runtime) |
|---|---|---|
| Mecanism | overloading: aceeași metodă, parametri diferiți | overriding: aceeași semnătură, rescrisă în subclasă |
| Când se alege metoda | la compilare, după tipurile argumentelor | la rulare, după obiectul real |
| Are nevoie de moștenire? | nu | da (sau de o interfață) |
| Exemplu | afiseaza(int) și afiseaza(String) | cost() în LivrareCurier și LivrareExpres |
Cele două mecanisme se confundă des, de aceea au o lecție dedicată, chiar următoarea din serie, despre overloading vs overriding.
Ce sunt upcasting și downcasting?
Upcasting înseamnă să folosești un obiect prin tipul părintelui (Livrare l = new LivrareExpres(1);) și se face automat, fără nicio conversie scrisă. Downcasting e drumul invers, de la tipul părintelui înapoi la tipul concret, și trebuie scris explicit.
După upcasting, tipul variabilei decide ce metode poți apela, iar obiectul real decide ce cod rulează:
Livrare l = new LivrareExpres(1);
System.out.println(l.cost()); // 37.0, versiunea din LivrareExpres
l.intervalOrar(); // eroare de compilare: Livrare nu are intervalOrar() Compilatorul vede doar o Livrare, care nu are metoda intervalOrar(). Dacă ai nevoie de ea, faci downcasting, dar întâi verifici tipul cu instanceof:
if (l instanceof LivrareExpres expres) {
System.out.println(expres.intervalOrar());
} Forma instanceof LivrareExpres expres verifică tipul și creează direct variabila convertită. Funcționează din Java 16. În versiunile mai vechi scrii verificarea și conversia separat: LivrareExpres expres = (LivrareExpres) l;. Fără verificare, o conversie greșită oprește programul cu ClassCastException.
Un sfat practic: dacă te trezești scriind des instanceof urmat de downcasting, polimorfismul nu e folosit cum trebuie. Mută comportamentul într-o metodă suprascrisă și lasă obiectul să decidă.
Cum folosești polimorfismul cu interfețe?
O interfață descrie ce trebuie să știe să facă o clasă, fără să spună cum, iar orice clasă care o implementează poate fi folosită prin tipul interfeței. E forma de polimorfism pe care o vei folosi cel mai des în proiecte reale.
public interface MetodaPlata {
boolean plateste(double suma);
}
public class PlataCard implements MetodaPlata {
public boolean plateste(double suma) {
System.out.println("Card: " + suma + " lei");
return true;
}
}
public class PlataRamburs implements MetodaPlata {
public boolean plateste(double suma) {
System.out.println("Ramburs la curier: " + suma + " lei");
return true;
}
}
public class Casa {
public void incaseaza(MetodaPlata metoda, double suma) {
metoda.plateste(suma);
}
}
Casa casa = new Casa();
casa.incaseaza(new PlataCard(), 149.9); // Card: 149.9 lei
casa.incaseaza(new PlataRamburs(), 89.0); // Ramburs la curier: 89.0 lei Spre deosebire de moștenire, o clasă poate implementa oricâte interfețe, iar clasele care implementează aceeași interfață nu trebuie să aibă nimic altceva în comun. În Spring Boot, aproape fiecare serviciu e folosit prin interfața lui, exact pe acest principiu. Mai multe despre interfețe găsești în tutorialul Oracle despre polimorfism.
Clasă abstractă sau interfață?
Alege o clasă abstractă când subclasele împart cod și stare comună, și o interfață când vrei doar un contract pe care clase foarte diferite îl pot respecta. Ambele permit polimorfismul și niciuna nu poate fi instanțiată direct cu new.
- Clasa abstractă
Livrareare sens pentru că toate livrările au o greutate și aceeași metodădescriere(). Le scrii o dată. - Interfața
MetodaPlataare sens pentru că o plată cu cardul și una ramburs nu au niciun atribut comun, doar aceeași acțiune.
O clasă poate extinde o singură clasă abstractă, dar poate implementa oricâte interfețe. Dacă nu ești sigur, începe cu o interfață.
De ce contează polimorfismul în proiectele reale?
Polimorfismul îți permite să adaugi funcționalități noi scriind cod nou, nu modificând cod care deja funcționează. Principiul are și un nume, Open/Closed: o clasă trebuie să fie deschisă pentru extindere și închisă pentru modificare.
Compară cu varianta fără polimorfism:
double cost(String tip, double kg) {
if (tip.equals("curier")) return 20 + 2 * kg;
else if (tip.equals("punct")) return 12;
else if (tip.equals("expres")) return 35 + 2 * kg;
throw new IllegalArgumentException("Tip necunoscut: " + tip);
} La fiecare tip nou de livrare modifici această metodă și, probabil, alte câteva care au același lanț de if-uri. O greșeală de tastare în „expres” trece de compilare și explodează abia în producție. Cu polimorfism, fiecare tip e o clasă separată, verificată de compilator, iar codul existent nu se atinge.
Ce greșeli fac începătorii cu polimorfismul?
Greșelile cu polimorfismul apar de obicei când logica de tip rămâne în afara obiectelor.
instanceofpeste tot. Un lanț deif (x instanceof A) ... else if (x instanceof B)e semn că ai nevoie de o metodă suprascrisă.- Confunzi overloading cu overriding. O metodă cu alți parametri în subclasă nu suprascrie, ci adaugă o metodă nouă. Pune
@Overrideși compilatorul te avertizează. - Subclase care încalcă contractul. Dacă
LivrarePunctRidicare.cost()ar returna un cost negativ sau ar arunca excepție, codul care lucrează cuLivrares-ar strica. - Tipuri concrete peste tot.
ArrayList<PlataCard>în loc deList<MetodaPlata>te leagă de o singură implementare. - Te aștepți ca metodele statice să fie polimorfice. Nu sunt. O metodă
staticse alege după tipul variabilei, nu după obiect.
Exercițiu: formele geometrice
Scrie o clasă abstractă Forma cu metoda abstractă double arie() și trei subclase: Cerc (rază), Dreptunghi (lățime, înălțime) și Triunghi (bază, înălțime). Pune câte o formă din fiecare într-o List<Forma>, calculează aria totală într-o singură buclă și afișează forma cu aria cea mai mare.
Apoi adaugă o a patra formă, Patrat, și verifică un lucru: bucla din main nu trebuie să se schimbe deloc. Dacă a trebuit să o modifici, polimorfismul nu e folosit complet.
Întrebări frecvente
Ce este polimorfismul în Java, pe scurt?
Este posibilitatea de a folosi obiecte diferite prin același tip (o clasă părinte sau o interfață), în timp ce fiecare obiect execută propria versiune a metodelor. Java alege versiunea la rulare, după obiectul real.
Polimorfismul are nevoie de moștenire?
Polimorfismul dinamic are nevoie de moștenire sau de o interfață, pentru că trebuie să existe un tip comun. Polimorfismul static, prin overloading, funcționează și într-o singură clasă.
Care este rolul upcasting-ului?
Îți permite să tratezi obiecte diferite la fel, de exemplu să le pui în aceeași listă sau să le trimiți aceleiași metode. Se face automat și e întotdeauna sigur.
Când trebuie folosit downcasting-ul?
Rar, doar când ai nevoie de o metodă care există numai în clasa concretă. Verifică întâi tipul cu instanceof, altfel riști ClassCastException.
Polimorfismul este folosit în Spring Boot?
Da, peste tot. Serviciile sunt declarate prin interfețe, iar Spring injectează implementarea concretă. Poți înlocui o implementare reală cu una de test fără să modifici codul care o folosește.
Primul pas: înlocuiește un lanț de if-uri
Caută în exercițiile tale un lanț de if-uri care verifică un tip sau un text („card”, „ramburs”, „transfer”). Transformă fiecare ramură într-o clasă care implementează aceeași interfață și înlocuiește lanțul cu un singur apel de metodă.
În cursul de Java exersezi polimorfismul pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Dacă nu înțelegi de ce rulează o anumită versiune a metodei, Profu’, tutorele AI din lecții, îți explică pas cu pas. Polimorfismul apare des la interviurile de junior, iar traseul complet îl găsești pe pagina Java Developer.
Lecția anterioară: cum citești diagrame UML. Lecția următoare: overloading vs overriding în Java.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
