Surcharge du constructeur dans Java

Qu'est-ce que la surcharge de constructeur dans Java?

Surcharge du constructeur dans Java Il s'agit d'une technique dans laquelle une classe déclare plusieurs constructeurs qui diffèrent par leur liste de paramètres. Le compilateur différencie ces constructeurs en analysant le nombre de paramètres et leurs types de données.

Exemples de constructeurs valides pour la classe Compte sont indiqués ci-dessous :

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

Pourquoi avons-nous besoin de la surcharge du constructeur dans Java?

Surcharge du constructeur dans Java Améliore la flexibilité et l'efficacité du code en autorisant plusieurs constructeurs dans une classe, chacun avec une liste de paramètres différente.

• Flexibilité dans la création d'objets : La surcharge de constructeurs permet d'initialiser des objets de différentes manières, en fonction du nombre ou du type de paramètres.
• Code Réutilisabilité: Vous pouvez réutiliser la logique du constructeur en appelant un constructeur depuis un autre à l'aide de cette() mot-clé.
• Lisibilité améliorée : La surcharge des constructeurs rend le code plus intuitif en offrant des options spécifiques pour différents besoins d'initialisation.
• Initialisation par défaut et personnalisée : La surcharge de constructeurs vous permet de créer facilement des objets initialisés par défaut et des objets personnalisés.

Exemple : Surcharge de constructeur dans Java

L'exemple suivant illustre la surcharge de constructeurs dans Java en utilisant une classe nommée Demo.

Étape 1) Tapez le code dans l'éditeur.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

Étape 2) Enregistrez, compilez et exécutez le code.

Étape 3) Une erreur s'est produite. Essayez de la corriger avant de passer à l'étape suivante de la surcharge de constructeurs. Java.

Étape 4) Chaque classe a une valeur par défaut Constructeur en Java. Le constructeur par défaut pour Démo de classe is Démo()Si vous ne le fournissez pas, le compilateur le crée pour vous et initialise les variables avec des valeurs par défaut.

Cependant, si vous spécifiez un constructeur paramétré comme Démo(int a) et je souhaite utiliser la valeur par défaut Démo(), il est obligatoire de le déclarer explicitement.

Étape 5) Décommentez les lignes 4 à 8 du code, puis enregistrez, compilez et exécutez à nouveau le programme pour observer le changement de comportement.

Chaînage de constructeurs dans Java

Considérons un scénario dans lequel une classe de base est étendue par un enfant. Chaque fois qu'un objet de la classe enfant est créé, le constructeur de la classe parent est invoqué en premier. C'est appelé chaînage de constructeurs.

Exemple : Pour comprendre le chaînage de constructeurs avec la surcharge de constructeurs dans Java

Étape 1) Copiez le code suivant dans l'éditeur.

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

Étape 2) Exécutez le code. En raison du chaînage des constructeurs, lorsque l'objet de la classe enfant DémoEnfant est créé, le constructeur Démo() La méthode de la classe parente est invoquée en premier, puis le constructeur. DémoEnfant() L'enfant court ensuite.

Production attendue:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

Étape 3) Vous pouvez observer que le constructeur parent Démo() s'exécute par défaut. Pour appeler le constructeur surchargé Démo(int a) Utilisez plutôt le mot-clé "super".

syntaxe:

super();
--or--
super(parameter list);

Exemple : Si votre constructeur parent ressemble à Démo(String Nom, int a), vous préciserez super("Java»,5). S'il est utilisé, le mot-clé super doit être la première ligne de code du constructeur de la classe enfant.

Étape 4) Décommentez la ligne 26 et exécutez le code. Observez le résultat.

Sortie :

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

FAQ