Come funzionano le classi, gli oggetti e i costruttori?

Question

IT Interview Practice · Accepted Answer

Una **classe** è un modello; un **oggetto** è un'istanza creata da essa. Un **costruttore** è un metodo speciale che inizializza un nuovo oggetto. Insieme costituiscono la base del modello orientato agli oggetti di Java.

## Definire una classe con un costruttore

```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;
    }
}
```

Il costruttore si esegue quando crei un oggetto, impostando il suo stato iniziale. `this` si riferisce all'oggetto corrente, disambiguando i campi dai parametri con lo stesso nome.

## Creazione di oggetti

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

La parola chiave `new` alloca memoria sullo heap e invoca il costruttore; `p` contiene un riferimento al nuovo oggetto.

## Sovraccarico e concatenamento del costruttore

```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)
    }
}
```

Puoi avere **più costruttori** con elenchi di parametri diversi (sovraccarico), e uno può chiamare un altro con `this(...)` per evitare di duplicare l'inizializzazione.

## Il costruttore predefinito

```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
```

Se non scrivi alcun costruttore, Java ne fornisce uno predefinito senza argomenti. Non appena definisci qualsiasi costruttore, quel predefinito scompare (devi aggiungerlo esplicitamente se necessario).

## Perché è importante

Classi, oggetti e costruttori sono l'assoluta base della programmazione Java — tutto ciò che costruisci è composto da oggetti creati da classi.

Comprendere come i costruttori inizializzano lo stato (`this`, il ruolo della parola chiave `new`, il sovraccarico e il concatenamento del costruttore per una creazione flessibile, e la regola del costruttore predefinito) è essenziale per creare e inizializzare correttamente gli oggetti.

Questi concetti sono alla base di tutto il lavoro OOP in Java, e il comportamento del costruttore (in particolare la scomparsa del predefinito e il concatenamento) è una fonte comune sia di domande di intervista che di bug reali.

Definire una classe con un costruttore

Creazione di oggetti

Sovraccarico e concatenamento del costruttore

Il costruttore predefinito

Perché è importante

Domande correlate