...
← Blog Lecții programare java

Constructor în Java: ce este, this, this() și super() explicate

Sigla Java, ilustrație pentru lecția despre constructorul în Java

Un constructor în Java este un bloc de cod special care rulează automat când creezi un obiect cu new și îi dă valorile de pornire. Are exact același nume ca clasa și nu are tip returnat, nici măcar void. Rolul lui e să garanteze că fiecare obiect pornește într-o stare corectă și completă.

Mai jos vezi cum declari un constructor, ce face this, ce e constructorul implicit și când dispare, cum scrii mai mulți constructori pentru aceeași clasă, cum îi legi cu this(), cum validezi datele și cum se comportă constructorii la moștenire, cu super().

Ce este un constructor în Java?

Un constructor este codul de inițializare al unui obiect, apelat o singură dată, la creare. În lecția despre clase și obiecte ai văzut deja unul. Acum îl luăm la bani mărunți, pe exemplul unei platforme de cursuri care înscrie cursanți:

public class Cursant {
    private String nume;
    private String email;
    private int lectiiTerminate;

    public Cursant(String nume, String email) {
        this.nume = nume;
        this.email = email;
        this.lectiiTerminate = 0;
    }
}

Cursant ana = new Cursant("Ana Pop", "ana@exemplu.ro");

Când Java execută new Cursant(...), face trei lucruri, în ordine: rezervă memorie pentru obiect și pune valorile implicite în atribute, rulează constructorul cu argumentele primite și returnează referința spre obiectul gata construit.

Care sunt regulile unui constructor?

Un constructor arată ca o metodă, dar respectă câteva reguli fixe, iar compilatorul ți le impune pe toate.

RegulăConstructorMetodă obișnuită
Numeidentic cu numele claseiorice nume valid
Tip returnatniciunul, nici voidobligatoriu (void, int, String…)
Când ruleazăautomat, o dată, la newde câte ori o apelezi
Se moștenește?nuda (dacă nu e private)
Poate fi static, final, abstract?nuda

O capcană clasică: dacă scrii public void Cursant(String nume, String email), cu void în față, nu ai un constructor. Ai o metodă care întâmplător se numește ca clasa, iar Java nu o apelează la new.

Ce înseamnă this într-un constructor?

this este o referință spre obiectul care tocmai se construiește. O folosești când parametrul are același nume ca atributul, ceea ce e convenția obișnuită în Java.

Uite ce se întâmplă fără this:

public Cursant(String nume, String email) {
    nume = nume;     // parametrul se atribuie lui însuși
    email = email;
}

Cursant ana = new Cursant("Ana Pop", "ana@exemplu.ro");
// ana are nume = null și email = null

Codul compilează fără nicio eroare, dar atributele rămân null. În interiorul constructorului, nume simplu înseamnă parametrul, pentru că e cel mai apropiat. this.nume înseamnă atributul obiectului. E una dintre greșelile care consumă cel mai mult timp de depanare la început, tocmai pentru că nu apare niciun mesaj.

Ce este constructorul implicit și când dispare?

Constructorul implicit este un constructor fără parametri pe care Java îl adaugă automat doar dacă tu nu ai scris niciun constructor. El nu face nimic special: atributele rămân la valorile implicite (0, false, null).

public class Produs {
    private String nume;
    private double pret;
    // niciun constructor scris
}

Produs p = new Produs();   // merge, Java a adăugat Produs() pentru tine

De îndată ce scrii un singur constructor, cu parametri, cel implicit dispare. Dacă după ce adaugi Produs(String nume, double pret) încerci new Produs(), compilatorul îți spune că nu găsește un constructor potrivit. Dacă ai nevoie de ambele variante, le scrii explicit pe amândouă.

Cum scrii mai mulți constructori pentru aceeași clasă?

O clasă poate avea oricâți constructori, cu condiția ca listele lor de parametri să difere prin număr, tip sau ordine. Asta se numește supraîncărcarea constructorilor (constructor overloading). Java alege constructorul după argumentele pe care le dai la new.

Ca să nu copiezi aceeași logică în fiecare constructor, îl apelezi pe cel complet din cele scurte, cu this(...):

public class Cursant {
    private final String email;
    private String nume;
    private String curs;
    private int lectiiTerminate;

    public Cursant(String nume, String email, String curs) {
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Email invalid: " + email);
        }
        this.nume = nume;
        this.email = email;
        this.curs = curs;
        this.lectiiTerminate = 0;
    }

    public Cursant(String nume, String email) {
        this(nume, email, "Java");   // cursul implicit
    }
}

Cursant ana = new Cursant("Ana Pop", "ana@exemplu.ro");
Cursant mihai = new Cursant("Mihai Ionescu", "mihai@exemplu.ro", "SQL");

Regula pentru this(...): trebuie să fie prima instrucțiune din constructor. Astfel, validarea emailului stă într-un singur loc și se aplică indiferent pe ce constructor intri.

De ce validezi datele în constructor?

Validarea în constructor garantează că nu poate exista niciun obiect invalid în program. Dacă cineva încearcă new Cursant("Ion", "ion.exemplu.ro"), obiectul nu se creează deloc, iar programul primește o excepție cu mesajul „Email invalid: ion.exemplu.ro”.

Alternativa, un constructor care acceptă orice și o metodă esteValid() apelată mai târziu, mută problema în altă parte. Mai devreme sau mai târziu, cineva uită să apeleze verificarea, iar un cursant fără email ajunge în baza de date.

Nu trebuie însă să ceri totul în constructor. Pune acolo doar ce e obligatoriu ca obiectul să aibă sens (numele, emailul). Ce se schimbă în timp, cum e numărul de lecții terminate, pornește de la o valoare fixă și se modifică prin metode.

Cum folosești final cu un constructor?

Un atribut final primește valoare o singură dată, iar constructorul e locul potrivit pentru asta. În exemplul de mai sus, email e final: se setează la înscriere și nu mai poate fi schimbat din greșeală. Dacă uiți să îl inițializezi pe una dintre ramurile constructorului, codul nu compilează.

Un exemplu frecvent e un număr de comandă unic, generat automat:

public class Comanda {
    private static int ultimulNumar = 0;
    private final int numar;
    private final String client;

    public Comanda(String client) {
        ultimulNumar++;
        this.numar = ultimulNumar;
        this.client = client;
    }
}

new Comanda("Ana");     // numar = 1
new Comanda("Mihai");   // numar = 2

ultimulNumar e static, deci comun tuturor comenzilor, iar numar e propriu fiecărei comenzi. Diferența dintre cele două o lămurește lecția următoare, despre static vs non-static.

Ce este un constructor de copiere?

Un constructor de copiere primește un obiect de același tip și construiește unul nou cu aceleași valori. Java nu îl generează automat, îl scrii tu când ai nevoie:

public Cursant(Cursant altul) {
    this(altul.nume, altul.email, altul.curs);
}

Cursant copie = new Cursant(ana);   // obiect nou, aceleași date

Atenție la atributele care sunt la rândul lor obiecte, de exemplu o listă de lecții. Dacă le copiezi doar referința, ambele obiecte vor împărți aceeași listă și o modificare într-unul apare și în celălalt. Pentru liste, creezi una nouă: this.lectii = new ArrayList<>(altul.lectii);.

Cum funcționează constructorii la moștenire?

Când creezi un obiect dintr-o clasă copil, Java rulează întâi constructorul clasei părinte, apoi pe cel al copilului. Apelul spre părinte se face cu super(...), care trebuie să fie prima instrucțiune din constructor.

class Animal {
    protected String nume;

    public Animal(String nume) {
        System.out.println("Constructor Animal");
        this.nume = nume;
    }
}

class Caine extends Animal {
    public Caine(String nume) {
        super(nume);
        System.out.println("Constructor Caine");
    }
}

new Caine("Rex");
// Constructor Animal
// Constructor Caine

Dacă nu scrii super(...), Java adaugă singur super() fără argumente. Când părintele nu are constructor fără parametri, ca Animal de aici, codul nu compilează până nu apelezi explicit constructorul potrivit. Moștenirea are lecția ei mai încolo în serie.

Ordinea completă la crearea unui obiect e: constructorul părintelui, apoi inițializările atributelor scrise la declarare și blocurile de inițializare (în ordinea din fișier), apoi corpul constructorului. Detaliile sunt în specificația limbajului Java, capitolul despre crearea instanțelor.

Ce greșeli fac începătorii cu constructorii?

Erorile cu constructorii se repetă de la un cursant la altul, așa că merită să le știi dinainte.

  1. Uiți de this. nume = nume compilează, dar lasă atributul gol.
  2. Pui void în fața constructorului. Devine metodă, iar obiectul se creează cu constructorul implicit.
  3. Te aștepți la constructorul implicit după ce ai scris altul. Nu mai există, trebuie scris explicit.
  4. Copiezi validarea în fiecare constructor. Folosește this(...) și ține logica într-un singur loc.
  5. Constructor cu 9 parametri. E greu de apelat corect (care String era emailul?). Păstrează în constructor doar ce e obligatoriu și setează restul prin metode.
  6. Operații lente în constructor. Citirea unui fișier mare sau un apel spre un server în constructor fac crearea obiectului lentă și greu de testat. Constructorul inițializează, nu lucrează.

Exercițiu: clasa ContBancar

Scrie clasa ContBancar cu atributele iban (final), titular și sold. Fă doi constructori: unul cu IBAN, titular și sold inițial, altul doar cu IBAN și titular, care pornește cu sold 0 și îl apelează pe primul cu this(...). Refuză un sold inițial negativ și un IBAN care nu începe cu „RO”.

Testează în main că un cont cu sold −100 nu se poate crea, iar unul fără sold pornește de la 0.

Întrebări frecvente

Poate o clasă să aibă mai mulți constructori?

Da, oricâți, atât timp cât listele de parametri diferă. Java îl alege pe cel potrivit după argumentele de la new, iar constructorii se pot apela între ei cu this(...).

Constructorul poate returna o valoare?

Nu. Constructorul nu are tip returnat, iar rezultatul lui este chiar obiectul creat, pe care îl primești de la new. Poți folosi return; fără valoare ca să ieși mai devreme, dar rar ai nevoie.

Care este diferența dintre constructor și metodă?

Constructorul are numele clasei, nu are tip returnat și rulează o singură dată, la crearea obiectului. O metodă are orice nume, are tip returnat și o apelezi de câte ori vrei pe un obiect existent.

Constructorii se moștenesc?

Nu. O clasă copil nu primește constructorii părintelui, dar trebuie să apeleze unul dintre ei cu super(...), explicit sau implicit, ca prima instrucțiune.

Ce este un constructor privat?

Este un constructor marcat private, care nu poate fi apelat din afara clasei. Se folosește la clasele utilitare care nu trebuie instanțiate și la clasele care oferă metode statice de creare, de tipul Pret.dinLei(49.99).

Primul pas: adaugă un constructor validat într-o clasă proprie

Ia clasa scrisă la lecția trecută și dă-i un constructor complet, cu validare, plus unul scurt care îl apelează cu this(...). Apoi încearcă să creezi intenționat un obiect invalid și verifică dacă excepția apare.

În cursul de Java exersezi constructorii 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 un atribut a rămas null când nu vezi singur. Pentru drumul complet spre primul job, vezi traseul de Java Developer.

Lecția anterioară: clase și obiecte în Java. Lecția următoare: static vs non-static î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