Surcharge de Constructeur en Java – Expliqué avec Exemples de Code Pratiques

Qu'est-ce qu'un Constructeur en Java ?

Un constructeur est une méthode spéciale qui initialise un objet nouvellement créé immédiatement après l'allocation mémoire. Il définit les champs de l'objet aux valeurs souhaitées ou, s'il est omis, à leurs valeurs par défaut. Définir un constructeur est optionnel ; s'il n'en est pas fourni, le compilateur en fournit un par défaut qui assigne les valeurs standard par défaut :

• Primitifs numériques (int, double, etc.) → 0
• char → '\0'
• Références d'objets → null

Ce tutoriel couvre :

• Règles pour créer des constructeurs
• Surcharge de constructeurs
• Chaînage de constructeurs

Règles pour Créer un Constructeur Java

1. Le nom du constructeur doit correspondre exactement au nom de la classe.
2. Il ne peut pas avoir de type de retour, pas même void.

Exemple 1 – Premier Constructeur

Étape 1 : Entrez le code suivant dans votre éditeur Java.

class Demo {
    int valeur1;
    int valeur2;
    Demo() {
        valeur1 = 10;
        valeur2 = 20;
        System.out.println("À l'intérieur du constructeur");
    }
    public void afficher() {
        System.out.println("Valeur1 === " + valeur1);
        System.out.println("Valeur2 === " + valeur2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.afficher();
    }
}

Étape 2 : Compilez et exécutez le programme. Sortie :

À l'intérieur du constructeur
Valeur1 === 10
Valeur2 === 20

Surcharge de Constructeur en Java

Java permet à une classe de définir plusieurs constructeurs avec des listes de paramètres différentes. Le compilateur les distingue par le nombre et les types de paramètres.

Des constructeurs valides pour une classe nommée Compte pourraient ressembler à :

Compte(int a);
Compte(int a, int b);
Compte(String a, int b);

Exemple 2 – Constructeurs Surchargés

Étape 1 : Insérez le code suivant.

class Demo {
    int valeur1;
    int valeur2;
    /* Demo() {
        valeur1 = 10;
        valeur2 = 20;
        System.out.println("À l'intérieur du 1er constructeur");
    } */
    Demo(int a) {
        valeur1 = a;
        System.out.println("À l'intérieur du 2ème constructeur");
    }
    Demo(int a, int b) {
        valeur1 = a;
        valeur2 = b;
        System.out.println("À l'intérieur du 3ème constructeur");
    }
    public void afficher() {
        System.out.println("Valeur1 === " + valeur1);
        System.out.println("Valeur2 === " + valeur2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(30);
        Demo d3 = new Demo(30, 40);
        d1.afficher();
        d2.afficher();
        d3.afficher();
    }
}

Étape 2 : Compilez et exécutez. Vous rencontrerez une erreur car le constructeur par défaut Demo() est manquant après l'ajout d'un constructeur paramétré. Pour utiliser le constructeur par défaut, déclarez-le explicitement :

Demo() {
    // initialisation par défaut ou logique personnalisée
}

Après avoir décommenté le bloc commenté et recompilé, le programme s'exécute correctement.

Chaînage de Constructeurs

Lorsqu'une sous-classe est instanciée, son constructeur de super-classe s'exécute en premier – c'est ce qu'on appelle le chaînage de constructeurs.

Exemple 3 – Chaînage entre Parent et Enfant

Étape 1 : Copiez le code ci-dessous.

class Demo {
    int valeur1;
    int valeur2;
    Demo() {
        valeur1 = 1;
        valeur2 = 2;
        System.out.println("À l'intérieur du 1er constructeur parent");
    }
    Demo(int a) {
        valeur1 = a;
        System.out.println("À l'intérieur du 2ème constructeur parent");
    }
    public void afficher() {
        System.out.println("Valeur1 === " + valeur1);
        System.out.println("Valeur2 === " + valeur2);
    }
    public static void main(String[] args) {
        DemoEnfant d1 = new DemoEnfant();
        d1.afficher();
    }
}
class DemoEnfant extends Demo {
    int valeur3;
    int valeur4;
    DemoEnfant() {
        // super(5); // Décommenter pour appeler le constructeur parent surchargé
        valeur3 = 3;
        valeur4 = 4;
        System.out.println("À l'intérieur du constructeur de l'enfant");
    }
    public void afficher() {
        System.out.println("Valeur1 === " + valeur1);
        System.out.println("Valeur2 === " + valeur2);
        System.out.println("Valeur3 === " + valeur3);
        System.out.println("Valeur4 === " + valeur4);
    }
}

Étape 2 : Exécutez le programme. Comme le constructeur enfant n'appelle pas explicitement super(), le constructeur par défaut Demo() s'exécute en premier. Sortie attendue :

À l'intérieur du 1er constructeur parent
À l'intérieur du constructeur de l'enfant
Valeur1 === 1
Valeur2 === 2
Valeur3 === 3
Valeur4 === 4

Étape 3 : Pour invoquer le constructeur parent surchargé Demo(int a), placez super(5); comme première ligne dans le constructeur enfant. Après décommenter la ligne et réexécuter :

À l'intérieur du 2ème constructeur parent
À l'intérieur du constructeur de l'enfant
Valeur1 === 5
Valeur2 === 0
Valeur3 === 3
Valeur4 === 4

L'utilisation de super(...) est obligatoire lorsque vous avez besoin qu'un constructeur de super-classe spécifique s'exécute avant la logique de la sous-classe.