Qu'est-ce que Constructor en Java?
CONSTRUCTOR est une méthode spéciale qui est utilisée pour initialiser un objet nouvellement créé et est 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 à 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 didacticiel, vous apprendrez-
- Règles de création d'un constructeur
- Surcharge du constructeur en Java
- Chaînage constructeur
Règles de création d'un constructeur Java
- Il porte le même nom que la classe
- Il ne doit pas renvoyer une valeur même pas nulle
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.
Production:
Inside ConstructorValue1 === 10Value2 === 20
Surcharge du constructeur en Java
La surcharge du constructeur 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 prenant en compte le nombre de paramètres dans la liste et 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 constructeur 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. Le constructeur Java surchargé par défaut pour la classe Demo est Demo () . 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 (), il est obligatoire pour vous de le spécifier.
En d'autres termes, dans le cas où 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
Prenons 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 appelé en premier. C'est ce qu'on appelle le chaînage du constructeur.
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 du constructeur, lorsque l'objet de la classe enfant DemoChild est créé, le constructeur Demo () de la classe parent est appelé en premier et le constructeur DemoChild () de l'enfant est créé ultérieurement. Sortie attendue =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Étape 3) Vous pouvez observer que le constructeur de la classe parent Demo est remplacé. Que faire si vous souhaitez appeler le constructeur remplacé Demo (int a) au lieu du constructeur par défaut Demo () lorsque votre objet enfant est créé?
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.
Production:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4