En Java, les constructeurs jouent un rôle crucial dans l'initialisation de l'instance de la classe. Celles-ci sont similaires aux méthodes Java. Cependant, le nom du constructeur est toujours le même que le nom de la classe alors qu'une méthode normale peut avoir n'importe quel nom valide. Généralement, celles-ci sont également appelées méthodes spéciales pour déclarer un objet. Vous pouvez créer un chaînage de constructeur qui se produit à l'aide de l'héritage. Le constructeur enfant/sous-classe appelle d'abord le constructeur parent/superclasse, puis les constructeurs de la classe enfant peuvent être appelés.
Cet article parlera du chaînage des constructeurs en Java.
Chaînage de constructeurs en Java
Le changement de constructeur est la procédure la plus importante pour appeler un constructeur dans un autre constructeur en fonction des objectifs énoncés. L'une des principales utilisations du chaînage de constructeurs est d'éviter les codes redondants tout en ayant plusieurs constructeurs. Cela rend le code facilement compréhensible et lisible.
Il existe deux méthodes pour effectuer le chaînage des constructeurs en Java, comme indiqué ci-dessous :
Examinons ces méthodes une par une pour mieux comprendre le chaînage des constructeurs.
Méthode 1 : chaînage de constructeurs dans la même classe à l'aide du mot-clé 'this()'
Lorsque le chaînage du constructeur est effectué au sein de la même classe, le Java ' ce() ” mot-clé est utilisé. Le constructeur par défaut sera appelé lorsqu'une instance de classe est lancée. Il appellera un autre constructeur en utilisant le ' ce ' mot-clé. Invoquez ensuite la méthode « println() » pour afficher le résultat sur la console :
min ( ) {
ce ( 5 ) ;
System.out.println ( 'Le constructeur par défaut' ) ;
}
Maintenant, appelez le deuxième constructeur composé d'un paramètre ' un ' et définissez la valeur des paramètres dans le ' ce() ' mot-clé. Ensuite, utilisez le ' println() ' et passez 'a' comme argument pour afficher le résultat :
ce ( 5 , vingt ) ;
System.out.println ( un ) ;
}
Dans ce constructeur, nous avons passé les deux paramètres de type entier comme ' un ' et ' b ”. Après cela, invoquez la méthode 'println ()' et passez ' un B ” qui renverra le produit de ces variables :
System.out.println ( un * b ) ;
}
Dans le ' principal() ”, invoquez le constructeur par défaut qui appellera automatiquement les autres constructeurs et affichera le résultat sur la console :
nouveau min ( ) ;
}
Par conséquent, la sortie de tous les constructeurs sera affichée sur la console :
Si vous souhaitez chaîner le constructeur dans plusieurs classes, consultez la méthode indiquée ci-dessous.
Méthode 2 : Chaînage du constructeur à une autre classe à l'aide du mot-clé 'super()'
Vous pouvez également chaîner les constructeurs d'une classe à l'autre. Pour cela, le mot-clé « super() » est utilisé. Pour ce faire, utilisez le code suivant dans la classe principale.
Tout d'abord, définissez une variable de type chaîne ' nom ” et appelez le premier constructeur en utilisant le nom de la classe principale :
nom de chaîne ;min ( ) {
ce ( '' ) ;
System.out.println ( 'Sans constructeur de classe de base' ) ;
}
Appelez le deuxième constructeur et passez la variable déclarée ci-dessus ' Nom de chaîne ” comme paramètre. Utilisez le ' ce ' mot-clé pour accéder à la valeur et invoquer le ' println() ” méthode à des fins d'impression :
this.name = nom;
System.out.println ( 'Appeler le constructeur paramétré de la base' ) ;
}
À l'intérieur de ' principal() ', appelez la classe enfant avec le paramètre ' nom ”. Cela appellera les constructeurs de classe parent où le paramètre ' nom ' est passé. Ensuite, il invoquera le constructeur de la classe enfant avec le paramètre ' nom ” :
nouvel enfant ( 'nom' ) ;
}
Une classe enfant est créée qui utilise le ' s'étend ” mot-clé pour hériter de la classe parent et invoquer le troisième constructeur. Après cela, appelez le constructeur suivant et à l'intérieur de ce constructeur, appelez le deuxième constructeur de la classe parent :
Enfant ( ) {
System.out.println ( 'Sans argument constructeur de classe enfant' ) ;
}
Enfant ( Nom de chaîne ) {
super ( nom ) ;
System.out.println ( 'Appel du constructeur paramétré de l'enfant' ) ;
}
}
Sortir
C'est tout sur le chaînage des constructeurs en Java.
Conclusion
En Java, le chaînage des constructeurs dans la même classe se fait à l'aide du mot-clé 'this()', tandis que le mot-clé 'super()' est utilisé pour effectuer le chaînage des constructeurs sur différentes classes. Le chaînage du constructeur se produit à l'aide de l'héritage. Le constructeur de la sous-classe appelle d'abord le constructeur de la super-classe, puis les constructeurs de la classe enfant peuvent être appelés. Cet article a discuté du chaînage de constructeurs en Java avec des exemples pratiques.