Surcharge du constructeur dans Java

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

Java La surcharge de constructeurs est une technique dans laquelle une classe peut avoir un nombre illimité de constructeurs dont la liste de paramètres diffère. Le compilateur différencie ces constructeurs en prenant en compte le nombre de paramètres dans la liste et leur type.

Voici des exemples de constructeurs valides pour la classe Account

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

Exemple 2: Pour comprendre la surcharge des constructeurs dans Java

É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) Erreur = ?. Essayez de déboguer l'erreur avant de passer à l'étape suivante de Java surcharge du constructeur

Étape 4) Chaque classe a une valeur par défaut Constructeur en Java. Constructeur surchargé par défaut Java pour Démo de classe is Démo(). Si vous ne fournissez pas ce constructeur, le compilateur le crée pour vous et initialise les variables aux valeurs par défaut. Vous pouvez choisir de remplacer ce constructeur par défaut et d'initialiser les variables aux valeurs souhaitées, comme indiqué dans l'exemple 1.

Mais si vous spécifiez un constructeur paramétré comme Demo(int a) et que vous souhaitez utiliser le constructeur par défaut Java Demo(), vous devez obligatoirement le préciser.

En d’autres termes, au cas où votre constructeur surchargerait Java est remplacé et vous souhaitez utiliser le constructeur par défaut Java, il faut le préciser.

Étape 5) Décommentez la ligne n°4-8. Enregistrez, compilez et exécutez le code.

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

Surcharge du constructeur dans Java permet d'avoir plusieurs constructeurs dans une classe, chacun ayant des listes de paramètres différentes. Cela améliore la flexibilité et l'efficacité du code.

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

Questions fréquentes

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Inside Constructor
Value1 === 10
Value2 === 20

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

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

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

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