Cum funcționează clasele, obiectele și constructorii?

Question

Accepted Answer

O **clasă** este o sablonă; un **obiect** este o instanță creată din aceasta. Un **constructor** este o metodă specială care inițializează un nou obiect. Împreună formează baza modelului orientat pe obiecte al Java.

## Definirea unei clase cu un constructor

```java
public class Person {
    private String name;        // fields (instance variables)
    private int age;

// CONSTRUCTOR — same name as the class, no return type
    public Person(String name, int age) {
        this.name = name;       // `this` distinguishes field from parameter
        this.age = age;
    }

public String greet() {     // method
        return "Hi, I'm " + name;
    }
}
```

Constructorul se execută atunci când creezi un obiect, configurând starea sa inițială. `this` se referă la obiectul curent, diferențiind câmpurile de parametrii cu același nume.

## Crearea obiectelor

```java
Person p = new Person("Ann", 30);   // `new` allocates the object + calls the constructor
p.greet();                           // "Hi, I'm Ann"
```

Cuvântul cheie `new` alocă memorie în heap și invocă constructorul; `p` conține o referință la noul obiect.

## Supraîncărcarea și înlănțuirea constructorilor

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {   // primary constructor
        this.name = name;
        this.age = age;
    }
    public Person(String name) {             // overloaded — different parameters
        this(name, 0);                        // calls the other constructor (chaining)
    }
}
```

Poți avea **mai mulți constructori** cu liste de parametri diferite (supraîncărcare), și unul poate apela altul cu `this(...)` pentru a evita duplicarea inițializării.

## Constructorul implicit

```java
public class Empty {
    // no constructor defined → Java provides an implicit no-arg constructor
}
Empty e = new Empty();   // works
// BUT: once you define ANY constructor, the implicit one is gone
```

Dacă nu scrii nici un constructor, Java furnizează uno implicit fără argumente. Imediat ce definești orice constructor, acel implicit dispare (trebuie să-l adaugi explicit dacă este necesar).

## De ce este important

Classele, obiectele și constructorii sunt baza absolută a programării în Java — totul ceea ce construiești este compus din obiecte create din clase.

Înțelegerea modului în care constructorii inițializează starea (`this`, rolul cuvântului cheie `new`, supraîncărcarea și înlănțuirea constructorilor pentru creație flexibilă, și regula constructorului implicit) este esențială pentru crearea și inițializarea corectă a obiectelor.

Aceste concepte stau la baza tuturor lucrărilor OOP în Java, și comportamentul constructorului (în special constructorul implicit care dispare și înlănțuirea) este o sursă comună atât de întrebări la interviuri cât și de bug-uri reale.