Les constructeurs sont des méthodes spéciales utilisées pour initialiser les objets lors de leur création. Dans cette section, vous apprendrez à utiliser le constructeur par défaut et à créer vos propres constructeurs personnalisés.

4.3Constructeurs

4.3.1 – Constructeur par défaut

Un constructeur est une méthode spéciale qui est appelée automatiquement lors de la création d'un objet avec le mot-clé new. Si vous ne définissez pas de constructeur dans votre classe, Java fournit automatiquement un constructeur par défaut (sans paramètres).

Exemple : Constructeur par défaut automatique

public class Personne {
    String nom;
    int age;
    
    // Pas de constructeur défini explicitement
    // Java fournit automatiquement : Personne() {}
}

// Utilisation
Personne p = new Personne();  // Utilise le constructeur par défaut
p.nom = "Jean";
p.age = 25;

🔍 Caractéristiques du constructeur par défaut

Il n'a aucun paramètre
Il ne fait rien (corps vide)
Il initialise les attributs avec leurs valeurs par défaut (0, null, false, etc.)
Il est automatiquement fourni si aucun constructeur n'est défini

Important : Si vous définissez un constructeur personnalisé, le constructeur par défaut n'est plus disponible automatiquement. Si vous en avez besoin, vous devez le définir explicitement.

Exemple : Constructeur par défaut perdu

public class Personne {
    String nom;
    int age;
    
    // Constructeur personnalisé défini
    public Personne(String nom) {
        this.nom = nom;
    }
}

// Utilisation
Personne p1 = new Personne("Jean");  // OK : utilise le constructeur personnalisé
// Personne p2 = new Personne();     // ❌ ERREUR : constructeur par défaut n'existe plus

// Solution : définir explicitement le constructeur par défaut
public class Personne {
    String nom;
    int age;
    
    public Personne() {  // Constructeur par défaut explicite
        // Corps vide ou initialisation par défaut
    }
    
    public Personne(String nom) {
        this.nom = nom;
    }
}

4.3.2 – Constructeurs personnalisés

Vous pouvez créer vos propres constructeurs pour initialiser les objets avec des valeurs spécifiques dès leur création. Cela permet de garantir que les objets sont créés dans un état valide.

Exemple : Constructeur personnalisé

public class Personne {
    String nom;
    int age;
    
    // Constructeur personnalisé avec paramètres
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
}

// Utilisation : initialisation directe
Personne p = new Personne("Jean", 25);  // Crée et initialise en une ligne
System.out.println(p.nom);  // Affiche : Jean
System.out.println(p.age);  // Affiche : 25

🔑 Le mot-clé this

Le mot-clé this fait référence à l'objet courant (l'instance en cours de création). Il est utilisé pour distinguer les paramètres des attributs quand ils ont le même nom.

Exemple : Utilisation de this

public class Personne {
    String nom;  // Attribut
    int age;     // Attribut
    
    public Personne(String nom, int age) {  // Paramètres
        // this.nom fait référence à l'attribut de l'objet
        // nom fait référence au paramètre
        this.nom = nom;  // Attribue le paramètre à l'attribut
        this.age = age;
    }
    
    // Sans this, il y aurait confusion
    public Personne(String nom, int age) {
        nom = nom;  // ❌ Problème : assigne le paramètre à lui-même !
        age = age;  // ❌ L'attribut n'est pas modifié
    }
}

📝 Surcharge de constructeurs (plusieurs constructeurs)

Vous pouvez définir plusieurs constructeurs dans la même classe, chacun avec des paramètres différents. C'est ce qu'on appelle la surcharge de constructeurs.

Exemple : Plusieurs constructeurs

public class Personne {
    String nom;
    int age;
    String ville;
    
    // Constructeur sans paramètres
    public Personne() {
        this.nom = "Inconnu";
        this.age = 0;
    }
    
    // Constructeur avec un seul paramètre
    public Personne(String nom) {
        this.nom = nom;
        this.age = 0;
    }
    
    // Constructeur avec deux paramètres
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
    
    // Constructeur avec trois paramètres
    public Personne(String nom, int age, String ville) {
        this.nom = nom;
        this.age = age;
        this.ville = ville;
    }
}

// Utilisation : Java choisit le bon constructeur selon les paramètres
Personne p1 = new Personne();                    // Utilise le constructeur sans paramètres
Personne p2 = new Personne("Jean");              // Utilise le constructeur avec 1 paramètre
Personne p3 = new Personne("Jean", 25);          // Utilise le constructeur avec 2 paramètres
Personne p4 = new Personne("Jean", 25, "Paris"); // Utilise le constructeur avec 3 paramètres

🔄 Appel d'un constructeur depuis un autre (this())

Un constructeur peut appeler un autre constructeur de la même classe en utilisant this(). Cela permet d'éviter la duplication de code.

Exemple : Appel de constructeur avec this()

public class Personne {
    String nom;
    int age;
    String ville;
    
    // Constructeur avec tous les paramètres
    public Personne(String nom, int age, String ville) {
        this.nom = nom;
        this.age = age;
        this.ville = ville;
    }
    
    // Constructeur qui appelle le constructeur principal
    public Personne(String nom, int age) {
        this(nom, age, "Inconnu");  // Appelle le constructeur avec 3 paramètres
    }
    
    // Constructeur qui appelle le constructeur avec 2 paramètres
    public Personne(String nom) {
        this(nom, 0);  // Appelle le constructeur avec 2 paramètres
    }
}

Important :

this() doit être la première instruction dans le constructeur
Un constructeur ne peut appeler qu'un seul autre constructeur
Vous ne pouvez pas utiliser this() et super() en même temps

💡 Points clés à retenir

Constructeur par défaut : Fourni automatiquement si aucun constructeur n'est défini
Constructeur personnalisé : Permet d'initialiser les objets avec des valeurs spécifiques
this : Référence à l'objet courant, utilisé pour distinguer paramètres et attributs
Surcharge : Plusieurs constructeurs avec des paramètres différents
this() : Appel d'un constructeur depuis un autre constructeur
Nom : Le constructeur a le même nom que la classe
Pas de type de retour : Un constructeur n'a pas de type de retour (même pas void)

Conseils pratiques :

Utilisez des constructeurs pour garantir que les objets sont créés dans un état valide
Créez plusieurs constructeurs pour offrir différentes façons d'initialiser un objet
Utilisez this() pour éviter la duplication de code entre constructeurs
Si vous définissez un constructeur personnalisé et avez besoin du constructeur par défaut, définissez-le explicitement