Comment fonctionnent les classes, les objets et les constructeurs ?

Question

Accepted Answer

Une **classe** est un modèle ; un **objet** est une instance créée à partir de celui-ci. Un **constructeur** est une méthode spéciale qui initialise un nouvel objet. Ensemble, ils constituent la base du modèle orienté objet de Java.

## Définir une classe avec un constructeur

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

Le constructeur s'exécute lorsque vous créez un objet, en mettant en place son état initial. `this` fait référence à l'objet courant, en levant l'ambiguïté entre les champs et les paramètres de même nom.

## Créer des objets

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

Le mot-clé `new` alloue de la mémoire sur le heap et invoque le constructeur ; `p` contient une référence au nouvel objet.

## Surcharge et chaînage de constructeurs

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

Vous pouvez avoir **plusieurs constructeurs** avec des listes de paramètres différentes (surcharge), et l'un peut appeler un autre avec `this(...)` pour éviter de dupliquer l'initialisation.

## Le constructeur par défaut

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

Si vous n'écrivez aucun constructeur, Java en fournit un par défaut sans argument. Dès que vous définissez un constructeur, ce défaut disparaît (vous devez l'ajouter explicitement si nécessaire).

## Pourquoi c'est important

Les classes, les objets et les constructeurs sont la base absolue de la programmation Java — tout ce que vous construisez est composé d'objets créés à partir de classes.

Comprendre comment les constructeurs initialisent l'état (`this`, le rôle du mot-clé `new`, la surcharge et le chaînage des constructeurs pour une création flexible, et la règle du constructeur par défaut) est essentiel pour créer et initialiser correctement des objets.

Ces concepts sous-tendent tout le travail orienté objet en Java, et le comportement des constructeurs (en particulier la disparition du défaut et le chaînage) est une source courante à la fois de questions d'entretien et de bugs réels.