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

FAQ

Constructeur est une méthode spéciale utilisée pour initialiser un objet nouvellement créé et appelée juste après l'allocation de la mémoire pour l'objet. Il peut être utilisé pour initialiser les objets aux valeurs souhaitées ou aux valeurs par défaut au moment de la création de l'objet. Il n'est pas obligatoire pour le codeur d'écrire un constructeur pour une classe.

Si aucun constructeur défini par l'utilisateur n'est fourni pour une classe, le compilateur initialise les variables membres à leurs valeurs par défaut.

  • les types de données numériques sont définis sur 0
  • Les types de données char sont définis sur le caractère nul ('\0')
  • les variables de référence sont définies sur null

  1. Il a la même nom comme la classe
  2. Il ne devrait même pas renvoyer de valeur annuler

Exemple 1: Créez votre premier constructeur dans Java

Étape 1) Tapez le programme constructeur suivant dans Java éditeur.

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

Étape 2) Enregistrez, exécutez et compilez le programme constructeur dans Java et observez la sortie.

Production attendue:

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

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 constructeur.

3 Exemple: Comprendre le chaînage des constructeurs

É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 DemoChild est créé, le constructeur Demo() de la classe parent est invoqué en premier et ensuite le constructeur DemoChild() de l'enfant est créé.

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 de la classe parent Demo est remplacé. Que se passe-t-il si vous souhaitez appeler le constructeur remplacé Demo(int a) au lieu du constructeur par défaut Demo() lors de la création de votre objet enfant ?

Dans de tels cas, vous pouvez utiliser le mot-clé "super" pour appeler les constructeurs remplacés de la classe parent.

Syntaxe:-

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

Mise en situation : Si votre constructeur est comme Démo (nom de chaîne, int a), vous préciserez super("Java»,5). S'il est utilisé, le mot-clé super doit être la première ligne de code dans le constructeur de la classe enfant.

Étape 4) Décommentez la ligne n°26 et exécutez le code. Observez la sortie.

Sortie :

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