
Moștenirea în Java (inheritance) este mecanismul prin care o clasă nouă preia atributele și metodele unei clase existente, cu ajutorul cuvântului extends. Clasa nouă, numită copil, poate adăuga lucruri proprii și poate rescrie metodele părintelui. Relația se descrie prin „este un”: un cont de economii este un cont bancar.
Mai jos construiești o mică ierarhie de conturi bancare și vezi pe ea ce se moștenește și ce nu, cum lucrează super, ce face protected, cum suprascrii o metodă cu @Override, de ce Java nu permite moștenire multiplă și când e mai bine să alegi compoziția.
Pentru exerciții pe fiecare concept, cursul Java pentru începători are primele 15 lecții gratuite, cu cod rulat direct în browser.
Ce este moștenirea în Java?
Moștenirea este relația dintre o clasă generală (părinte, superclasă) și o clasă mai specifică (copil, subclasă), în care copilul primește tot ce are părintele și adaugă ce îi lipsește. Ea răspunde unei probleme concrete: duplicarea codului.
Să zicem că o bancă are conturi curente și conturi de economii. Amândouă au IBAN, sold, depunere și retragere. Diferă doar ce se întâmplă la final de lună: contul curent plătește un comision, iar cel de economii primește dobândă. Fără moștenire, scrii de două ori aceeași logică de depunere și retragere. Cu moștenire, o scrii o dată, în clasa părinte.
Moștenirea e unul dintre cele patru principii ale programării orientate pe obiect, alături de încapsulare, polimorfism și abstractizare.
Cum funcționează extends în Java?
Scrii class Copil extends Parinte, iar clasa copil primește automat toate metodele și atributele accesibile ale părintelui. Începem cu clasa părinte:
public class ContBancar {
private final String iban;
protected double sold;
public ContBancar(String iban, double soldInitial) {
this.iban = iban;
this.sold = soldInitial;
}
public void depune(double suma) {
if (suma <= 0) {
throw new IllegalArgumentException("Suma trebuie să fie pozitivă");
}
sold += suma;
}
public boolean retrage(double suma) {
if (suma > sold) {
return false;
}
sold -= suma;
return true;
}
public void finalDeLuna() {
// contul de bază nu face nimic special
}
public String getIban() { return iban; }
public double getSold() { return sold; }
} Și o clasă copil, care adaugă dobânda:
public class ContEconomii extends ContBancar {
private final double dobandaLunara;
public ContEconomii(String iban, double soldInitial, double dobandaLunara) {
super(iban, soldInitial); // construiește partea de părinte
this.dobandaLunara = dobandaLunara;
}
@Override
public void finalDeLuna() {
sold += sold * dobandaLunara;
}
} ContEconomii nu are scrise metodele depune, retrage sau getSold, dar le poate folosi pe toate. Codul a fost scris o dată, în ContBancar, și e moștenit.
Ce se moștenește și ce nu?
Clasa copil moștenește metodele și atributele public și protected, dar nu primește constructorii și nu poate accesa direct membrii private ai părintelui. Tabelul de mai jos îți arată exact ce vede copilul:
| Membru în părinte | Îl vede clasa copil? | Observație |
|---|---|---|
public | da | îl vede oricine |
protected | da | și clasele din același pachet |
| fără modificator (package-private) | doar dacă e în același pachet | despre pachete e ultima lecție din serie |
private | nu direct | există în obiect, dar se folosește prin metodele publice (getIban()) |
| constructori | nu se moștenesc | se apelează cu super(...) |
metode static | da, dar nu se suprascriu | se pot doar ascunde |
În exemplu, iban e private: copilul nu poate scrie this.iban = ..., dar îl poate citi prin getIban(). sold e protected, ca să îl poată modifica dobânda din ContEconomii. Folosește protected cu măsură: orice atribut protected poate fi schimbat de orice subclasă, deci pierzi o parte din controlul pe care ți-l dădea încapsularea.
Ce face super în Java?
super este referința spre partea de părinte a obiectului curent și are două utilizări: super(...) apelează constructorul părintelui, iar super.metoda() apelează versiunea părintelui a unei metode suprascrise.
Constructorul copilului trebuie să construiască întâi partea de părinte, iar super(...) trebuie să fie prima instrucțiune din el. Dacă nu îl scrii, Java adaugă automat super() fără argumente. Cum ContBancar nu are un constructor fără parametri, un ContEconomii fără super(iban, soldInitial) nu ar compila.
A doua utilizare apare când vrei să extinzi comportamentul părintelui, nu să îl înlocuiești complet:
public class ContCurent extends ContBancar {
private final double comisionLunar;
public ContCurent(String iban, double soldInitial, double comisionLunar) {
super(iban, soldInitial);
this.comisionLunar = comisionLunar;
}
@Override
public void finalDeLuna() {
sold -= comisionLunar;
}
@Override
public boolean retrage(double suma) {
boolean reusit = super.retrage(suma); // logica părintelui
if (reusit) {
System.out.println("Retragere de " + suma + " lei din contul curent");
}
return reusit;
}
} Verificarea soldului rămâne în ContBancar, într-un singur loc. Copilul adaugă doar mesajul.
Cum suprascrii o metodă cu @Override?
Suprascrierea (method overriding) înseamnă că clasa copil scrie propria versiune a unei metode moștenite, cu exact aceeași semnătură. Adnotarea @Override îi cere compilatorului să verifice că metoda chiar există în părinte.
Fără @Override, o greșeală de tastare trece neobservată. Dacă scrii finalDeluna() cu „l” mic, Java crede că ai creat o metodă nouă, iar la final de lună rulează în continuare metoda goală din părinte. Cu @Override, codul nu compilează și vezi greșeala imediat. Pune-o mereu.
Partea interesantă apare când ții obiecte diferite într-o listă de tipul părintelui:
List<ContBancar> conturi = List.of(
new ContCurent("RO01CURENT", 1000, 5),
new ContEconomii("RO02ECONOM", 10000, 0.005)
);
for (ContBancar cont : conturi) {
cont.finalDeLuna();
System.out.println(cont.getIban() + ": " + cont.getSold() + " lei");
}
// RO01CURENT: 995.0 lei
// RO02ECONOM: 10050.0 lei Bucla apelează aceeași metodă, dar fiecare cont face altceva: unul scade comisionul, celălalt adaugă dobânda. Java alege versiunea după obiectul real, nu după tipul variabilei. Acesta e polimorfismul, despre care vorbim pe larg peste două lecții.
De ce Java nu permite moștenire multiplă?
O clasă Java poate extinde o singură clasă, pentru a evita conflictele în care două clase părinte au aceeași metodă cu implementări diferite. Dacă ContEconomii ar extinde și ContBancar, și ProdusFinanciar, iar ambele ar avea finalDeLuna(), compilatorul n-ar ști pe care să o folosească.
Ce poți face în schimb e să implementezi oricâte interfețe: class ContEconomii extends ContBancar implements Raportabil, Exportabil. O interfață descrie ce trebuie să știe să facă o clasă, fără să îi impună o ierarhie. Toate clasele Java au oricum un părinte comun, Object, de la care moștenesc toString(), equals() și hashCode().
Două cuvinte-cheie îți permit să oprești moștenirea. O clasă final (cum e String) nu poate fi extinsă deloc. O metodă final nu poate fi suprascrisă, util când o regulă din părinte, cum ar fi verificarea soldului, nu trebuie ocolită de nicio subclasă.
Moștenire sau compoziție: când alegi moștenirea?
Alege moștenirea doar când relația e un „este un” adevărat și obiectul copil poate fi folosit oriunde e așteptat părintele, fără surprize. În toate celelalte cazuri, compoziția din lecția trecută e alegerea mai sigură.
Regula aceasta are și un nume: principiul substituției al lui Liskov. Pe înțeles, dacă un cod funcționează cu un ContBancar, trebuie să funcționeze la fel de bine cu orice subclasă a lui. Dacă ai o subclasă ContBlocat care aruncă excepție la orice depunere, încalci regula: codul care primește „un cont bancar” se strică brusc.
- Moștenire potrivită:
ContEconomii extends ContBancar,Caine extends Animal,FacturaFiscala extends Document. - Moștenire greșită:
Masina extends Motor(mașina are un motor),Comanda extends ArrayList(comanda are produse),Patrat extends Dreptunghi, dacă dreptunghiul aresetLatime()șisetInaltime()separate, pe care un pătrat nu le poate respecta.
Ține ierarhiile scurte. Două, cel mult trei niveluri sunt ușor de urmărit. La cinci niveluri, ca să înțelegi ce face o metodă, ajungi să deschizi cinci fișiere.
Ce greșeli fac începătorii cu moștenirea?
Majoritatea problemelor cu moștenirea vin din folosirea ei acolo unde relația nu e „este un”.
extendsdoar ca să refolosești cod. Dacă relația e „are un”, folosește compoziția.- Uiți
@Override. O greșeală în numele metodei creează o metodă nouă în loc să o suprascrie. - Uiți
super(...)când părintele nu are constructor fără parametri. Codul nu compilează, iar mesajul pare confuz la început. - Toate atributele
protected. Subclasele pot strica starea părintelui. Păstrează-leprivateși expune metode. - Downcasting peste tot. Dacă scrii des
if (cont instanceof ContEconomii), probabil ai nevoie de o metodă suprascrisă, nu de verificări de tip. - Subclase care „dezactivează” metode ale părintelui. O metodă suprascrisă care doar aruncă excepție e semn că ierarhia e greșită.
Pentru detaliile formale, tutorialul Oracle despre moștenire e o lectură bună, în engleză.
Exercițiu: angajații unei firme
Scrie clasa Angajat cu atributele nume și salariuDeBaza și metoda salariuLunar(), care returnează salariul de bază. Creează două subclase: Programator, care primește un bonus fix pe lună, și Vanzator, care primește un comision de 5% din vânzările lunii. Fiecare suprascrie salariuLunar() cu @Override și folosește super.salariuLunar().
Pune trei angajați diferiți într-o List<Angajat> și calculează totalul salariilor într-o singură buclă, fără niciun instanceof.
Întrebări frecvente
Ce face extends în Java?
Declară că o clasă moștenește o altă clasă. Clasa copil primește metodele și atributele accesibile ale părintelui și poate adăuga altele sau suprascrie metode existente.
Poate o clasă Java să extindă două clase?
Nu. Java permite o singură clasă părinte, ca să evite conflictele dintre implementări. Poți însă implementa oricâte interfețe.
Constructorii sunt moșteniți?
Nu. Fiecare clasă își scrie constructorii, iar constructorul copilului trebuie să apeleze unul dintre constructorii părintelui cu super(...), ca primă instrucțiune.
Membrii private sunt moșteniți?
Ei există în obiectul copil, dar copilul nu îi poate accesa direct. Îi folosește prin metodele publice sau protected ale părintelui, cum sunt getterii.
Când aleg moștenirea și când compoziția?
Moștenirea, când relația e „este un” și copilul poate înlocui oricând părintele. Compoziția, când relația e „are un” sau când vrei să poți schimba piesele. Dacă ești în dubiu, alege compoziția.
Primul pas: găsește codul duplicat
Caută în exercițiile tale două clase care au aceleași atribute și aceleași metode, cu mici diferențe. Verifică dacă propoziția „X este un Y” sună corect. Dacă da, mută partea comună într-o clasă părinte și lasă în copii doar diferențele, cu @Override.
În cursul de Java exersezi moștenirea pe exerciții verificate automat, direct în browser, iar primele 15 lecții sunt gratuite. Când un super(...) lipsă îți blochează compilarea, Profu’, tutorele AI din lecții, îți explică mesajul. Pentru tot drumul până la primul job, vezi traseul de Java Developer.
Lecția anterioară: compoziția în Java. Lecția următoare: cum citești diagrame UML.
Curs Java
Programare Java pentru începători: de la sintaxă la OOP și colecții
Începe gratuit
