Surcharge de constructeurs en Java :Qu'est-ce que c'est et exemples de programmes

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

Constructeur est une méthode spéciale qui est utilisée pour initialiser un objet nouvellement créé et qui est appelée juste après que la mémoire est allouée 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 à ses 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 un caractère nul (‘\0’)
• les variables de référence sont définies sur null

Dans ce tutoriel, vous apprendrez-

• Règles de création d'un constructeur
• Surcharge de constructeur en Java
• Chaînage constructeur

Règles de création d'un constructeur Java

1. Il porte le même nom comme la classe
2. Il ne doit pas renvoyer de valeur même void

Exemple 1 :Créez votre premier constructeur en Java

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

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 en Java et observez la sortie.

Sortie :

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

Surcharge de constructeur en Java

La surcharge de constructeurs Java est une technique dans laquelle une classe peut avoir n'importe quel nombre de constructeurs qui diffèrent dans la liste des paramètres. Le compilateur différencie ces constructeurs en tenant compte du nombre de paramètres dans la liste et de leur type.

Des exemples de constructeurs valides pour la classe Account sont

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

Exemple 2  :Pour comprendre la surcharge de constructeurs en 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 la surcharge du constructeur Java

Étape 4) Chaque classe a un constructeur par défaut en Java. Constructeur Java surchargé par défaut pour class Demo est 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 avec les valeurs souhaitées, comme indiqué dans l'exemple 1.

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

En d'autres termes, si votre constructeur de surcharge en Java est remplacé et que vous souhaitez utiliser le constructeur par défaut Java, il doit être spécifié.

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

Chaînage constructeur

Considérez 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 ce qu'on appelle le chaînage de constructeurs.

Exemple 3 : Pour 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, puis le constructeur DemoChild() de l'enfant est créé.

Sortie 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 surchargés de la classe parent.

Syntaxe :-

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

Exemple : Si votre constructeur est comme Demo(String Name,int a) , vous spécifierez 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 # 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