
Diferența dintre overloading și overriding în Java: overloading (supraîncărcare) înseamnă mai multe metode cu același nume, dar cu parametri diferiți, în aceeași clasă, iar Java alege metoda la compilare. Overriding (suprascriere) înseamnă că o clasă copil rescrie o metodă moștenită, cu exact aceeași semnătură, iar Java alege versiunea la rulare, după obiectul real.
Dacă vrei să înveți practic, curs Java pentru începători are primele lecții gratuite, cu exerciții verificate direct în browser.
Mai jos ai un tabel complet cu diferențele, regulile fiecărui mecanism, cum alege Java între metode supraîncărcate, capcanele cu null și cu tipurile numerice, plus cazurile speciale care apar la interviuri: metode statice, private și final.
Care e diferența dintre overloading și overriding?
Overloading oferă mai multe variante ale aceleiași operații, pentru date de intrare diferite. Overriding schimbă comportamentul unei operații moștenite pentru un tip mai specific. Două exemple scurte fac diferența clară:
// Overloading: aceeași clasă, același nume, parametri diferiți
class Calculator {
int aduna(int a, int b) { return a + b; }
int aduna(int a, int b, int c) { return a + b + c; }
double aduna(double a, double b) { return a + b; }
}
// Overriding: clasa copil rescrie metoda părintelui
class Raport {
public String genereaza() { return "Raport general"; }
}
class RaportVanzari extends Raport {
@Override
public String genereaza() { return "Raport vânzări: " + super.genereaza(); }
} Tabelul de mai jos adună toate diferențele pe care trebuie să le știi:
| Criteriu | Overloading | Overriding |
|---|---|---|
| Unde apare | de obicei în aceeași clasă | între clasa părinte și clasa copil |
| Parametrii | trebuie să difere (număr, tip sau ordine) | trebuie să fie identici |
| Tipul returnat | poate fi oricare, dar nu e suficient singur | același sau un subtip (covariant) |
| Modificatorul de acces | oricare | la fel sau mai permisiv, niciodată mai restrictiv |
| Când se alege metoda | la compilare | la rulare |
| Tip de polimorfism | static | dinamic |
| Are nevoie de moștenire? | nu | da (sau de o interfață) |
Metode static, private, final | pot fi supraîncărcate | nu pot fi suprascrise |
| Adnotare | niciuna | @Override, recomandată mereu |
Ce este method overloading în Java?
Method overloading înseamnă să declari mai multe metode cu același nume, care diferă prin lista de parametri. Îl folosești când aceeași operație are sens pentru date diferite. Exemplul pe care îl vezi zilnic e System.out.println(), care are versiuni pentru int, double, String, boolean și altele.
Parametrii pot diferi în trei feluri:
- prin număr:
aduna(int a, int b)șiaduna(int a, int b, int c); - prin tip:
aduna(int a, int b)șiaduna(double a, double b); - prin ordine:
inscrie(String nume, int varsta)șiinscrie(int varsta, String nume)(permis, dar derutant, deci evită-l).
Un caz practic, un serviciu de notificări pentru o platformă de cursuri:
class Notificare {
void trimite(String mesaj) {
System.out.println("Mesaj: " + mesaj);
}
void trimite(String mesaj, String destinatar) {
System.out.println(destinatar + ": " + mesaj);
}
} Ce nu contează pentru overloading: numele parametrilor și tipul returnat. Două metode int calculeaza(int x) și double calculeaza(int x) nu pot sta în aceeași clasă. Compilatorul spune că metoda „is already defined”, pentru că la apelul calculeaza(5) nu ar avea cum să aleagă.
Cum alege Java metoda supraîncărcată?
Java caută metoda cea mai specifică ce se potrivește argumentelor, în trei etape: întâi potrivirea exactă sau lărgirea tipului primitiv (widening), apoi autoboxing, abia la final varargs. Prima etapă care găsește o metodă câștigă.
static void f(long x) { System.out.println("long"); }
static void f(Integer x) { System.out.println("Integer"); }
static void f(int... x) { System.out.println("varargs"); }
f(5); // long Surprinzător pentru mulți: 5 e un int, dar Java preferă să îl lărgească la long decât să îl împacheteze în Integer. Varargs e ultima variantă. Tot din același motiv, aduna(2, 3.5) pe calculatorul de mai sus apelează versiunea cu double și returnează 5.5. Regulile complete sunt în specificația limbajului Java, secțiunea despre alegerea metodei.
O capcană înrudită apare la null. Dacă ai g(String s) și g(Object o), apelul g(null) alege String, pentru că e tipul mai specific. Dacă ai g(String s) și g(Integer i), același apel nu compilează: ambele sunt la fel de specifice, iar apelul e ambiguu.
Ce este method overriding în Java?
Method overriding înseamnă că o clasă copil furnizează propria implementare pentru o metodă moștenită, păstrând exact numele și parametrii. E mecanismul din spatele polimorfismului dinamic: Java decide ce versiune rulează după obiectul real, nu după tipul variabilei.
class Livrare {
double cost(double kg) { return 20 + 2 * kg; }
}
class LivrareExpres extends Livrare {
@Override
double cost(double kg) { return super.cost(kg) + 15; }
}
Livrare l = new LivrareExpres();
System.out.println(l.cost(3)); // 41.0, versiunea din LivrareExpres Variabila e de tip Livrare, dar obiectul e LivrareExpres, deci rulează versiunea suprascrisă. Pe acest mecanism se bazează tot ce ai văzut în lecția trecută despre polimorfism.
Care sunt regulile pentru overriding?
O metodă suprascrisă trebuie să poată înlocui oricând metoda părintelui, iar toate regulile vin din această idee. Codul care lucrează cu tipul părinte nu trebuie să aibă surprize.
- Aceeași semnătură: același nume, aceiași parametri, în aceeași ordine.
- Tipul returnat: același sau un subtip.
Raport copie()poate deveniRaportVanzari copie()în clasa copil (tip returnat covariant). - Accesul nu se restrânge: o metodă
publicnu poate deveniprotectedsau package-private. Compilatorul refuză cu „cannot override”, pentru că un cod care o apela prin părinte n-ar mai avea voie. - Excepțiile verificate nu se extind: metoda copil poate arunca aceleași excepții verificate sau mai puține, nu altele noi, mai generale.
- Doar metodele de instanță moștenite: metodele
static,privateșifinalnu se suprascriu.
De ce să pui mereu @Override?
Adnotarea @Override îi cere compilatorului să verifice că metoda chiar suprascrie ceva. Fără ea, o greșeală transformă suprascrierea, pe tăcute, într-o supraîncărcare.
class LivrareExpres extends Livrare {
// intenția: suprascriere. Realitatea: overloading, alți parametri
double cost(double kg, boolean weekend) {
return cost(kg) + (weekend ? 10 : 0);
}
} Codul compilează, dar l.cost(3) pe un obiect LivrareExpres rulează în continuare versiunea părintelui. Cu @Override deasupra, compilatorul ar fi spus imediat „method does not override or implement a method from a supertype”. Același lucru se întâmplă dacă scrii greșit numele, de exemplu Cost în loc de cost, sau equals(Produs p) în loc de equals(Object o), o greșeală clasică.
Metodele statice, private și final se pot suprascrie?
Nu, niciuna dintre ele, dar din motive diferite. Sunt întrebări care apar des la interviurile de junior, așa că merită să le știi pe rând.
- Metode
static: aparțin clasei, nu obiectului. O metodă statică cu același nume în copil o ascunde pe cea a părintelui (hiding), iar Java o alege după tipul variabilei, nu după obiect. - Metode
private: nu sunt vizibile în clasa copil, deci nu au ce să fie suprascrise. O metodă cu același nume în copil e pur și simplu o metodă nouă, fără legătură. - Metode
final: sunt marcate explicit ca nemodificabile. Încercarea de a le suprascrie dă eroare de compilare. - Constructori: nu se moștenesc, deci nu se suprascriu. Se pot însă supraîncărca, așa cum ai văzut în lecția despre constructori.
Toate aceste metode pot fi, în schimb, supraîncărcate liniștit.
Când folosești overloading și când overriding?
Folosești overloading când vrei mai multe moduri comode de a apela aceeași operație și overriding când un tip mai specific trebuie să se comporte diferit. Nu sunt alternative una la alta. Răspund la întrebări diferite.
- Overloading: o metodă
cauta(String nume)și unacauta(int id); constructori cu mai multe variante; metode cu un parametru opțional (trimite(mesaj)șitrimite(mesaj, destinatar)). - Overriding:
toString(),equals()șihashCode()în orice clasă; calculul costului în fiecare tip de livrare; implementarea metodelor dintr-o interfață.
Nu exagera cu overloading-ul. Cinci variante ale aceleiași metode, care diferă doar prin tipuri numerice, duc la apeluri greu de prezis. Uneori nume diferite (cautaDupaNume, cautaDupaId) sunt mai clare.
Ce greșeli fac începătorii la overloading și overriding?
Aproape toate greșelile vin din semnături care diferă puțin de cea intenționată.
- Schimbi doar tipul returnat. Nu e overloading valid, codul nu compilează.
- Schimbi parametrii în clasa copil. Crezi că suprascrii, dar supraîncarci. Pune
@Override. - Restrângi accesul.
publicîn părinte, fără modificator în copil: eroare de compilare. - Crezi că metodele statice sunt polimorfice. Rezultatul depinde de tipul variabilei.
- Suprascrierea schimbă sensul metodei. Dacă
cost()în copil returnează altceva decât un cost, încalci contractul părintelui.
Pentru alte capcane de început, citește și articolul despre greșelile frecvente ale începătorilor în Java.
Exercițiu: identifică mecanismul
Pentru fiecare pereche de mai jos, spune dacă e overloading, overriding sau eroare de compilare (clasa B extinde clasa A):
- A:
void plateste(double suma), B:void plateste(double suma, String moneda); - A:
public String nume(), B:public String nume(); - A:
public void salveaza(), B:void salveaza(); - în aceeași clasă:
int total()șidouble total().
Răspunsuri: 1 e overloading, 2 e overriding, 3 și 4 sunt erori de compilare. Verifică-le scriind codul și citind mesajele compilatorului.
Întrebări frecvente
Overloading și overriding sunt același lucru?
Nu. Overloading înseamnă metode cu același nume și parametri diferiți, alese la compilare. Overriding înseamnă rescrierea unei metode moștenite, cu aceeași semnătură, aleasă la rulare.
Este necesară moștenirea pentru overloading?
Nu. Overloading-ul funcționează într-o singură clasă. Poate apărea și între părinte și copil, dacă copilul adaugă o metodă cu același nume și alți parametri.
Poate tipul returnat să fie diferit la overriding?
Doar dacă e un subtip al celui original. Dacă părintele returnează Raport, copilul poate returna RaportVanzari. Un tip fără legătură dă eroare de compilare.
Constructorii pot fi suprascriși?
Nu, pentru că nu se moștenesc. Pot fi însă supraîncărcați: o clasă poate avea mai mulți constructori cu parametri diferiți.
Este obligatoriu să folosesc @Override?
Nu, codul compilează și fără ea. Dar e o practică universală, pentru că transformă o greșeală tăcută într-o eroare de compilare vizibilă.
Primul pas: pune @Override peste tot
Deschide exercițiile cu moștenire scrise până acum și adaugă @Override peste fiecare metodă care ar trebui să suprascrie ceva. Dacă vreuna nu mai compilează, ai găsit un bug care stătea ascuns.
În cursul de Java exersezi ambele mecanisme pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Profu’, tutorele AI din lecții, îți explică de ce Java a ales o anumită metodă supraîncărcată. Întrebarea „overloading vs overriding” e una dintre cele clasice la interviurile pentru Java Developer.
Lecția anterioară: polimorfism în Java. Lecția următoare: constante și final în Java.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
