Surcharge de constructeur en Java : explication, avantages et exemples
Publié: 2021-07-22Table des matières
Bases de Java
Java, avec ses fonctionnalités remarquables et dynamiques, s'est imposé comme l'un des choix les plus recherchés des développeurs pour la programmation à grande échelle d'applications Web. C'est un langage convivial avec un large éventail de fonctionnalités extraordinaires. Sa compatibilité avec tous les systèmes d'exploitation est la richesse de l'API qui l'a rendu populaire dans le monde entier. Le langage offre un support communautaire robuste et d'excellents services de documentation. Java dispose d'une suite d'outils de développement solides.
Constructeurs en Java
Les constructeurs en Java sont utilisés pour initialiser l'état de l'objet. Tout comme les méthodes, les constructeurs contiennent également un groupe d'instructions ou d'instructions qui doivent être exécutées lors de la création d'un objet.
Pourquoi avons-nous besoin d'un constructeur en Java ?
Considérons une boîte. Si la boîte est supposée être une classe, elle peut avoir plusieurs variables telles que la largeur, la longueur et la hauteur. Lorsqu'un objet doit être créé, la classe de boîte n'aura pas de valeurs définies pour ses dimensions. Lors de la création de nouveaux objets, les constructeurs attribuent des valeurs aux variables de la classe. L'affectation des valeurs peut être effectuée soit à l'aide des constructeurs Java par défaut, soit explicitement par les paramètres passés par le programmeur.
Quand un constructeur est-il invoqué ?
Au moins un constructeur est appelé à chaque fois qu'un objet est créé à l'aide du mot-clé new(). Ce constructeur fournit des valeurs initiales aux membres de données de la classe. En général, un constructeur est appelé lorsqu'un nouvel objet ou une nouvelle instance est créé.
Surcharge de constructeur en Java
Le processus de définition de plusieurs constructeurs de la même classe est appelé surcharge de constructeur. Cependant, chaque constructeur doit avoir une signature ou des paramètres d'entrée différents. En d'autres termes, la surcharge de constructeur en Java est une technique qui permet à une seule classe d'avoir plusieurs constructeurs qui varient en fonction de la liste des arguments passés. Chaque constructeur surchargé est utilisé pour effectuer différentes tâches dans la classe.
Le compilateur Java identifie les constructeurs surchargés sur la base de leurs listes de paramètres, des types de paramètres et du nombre de paramètres d'entrée. Par conséquent, les constructeurs surchargés doivent avoir des signatures différentes. La signature d'un constructeur contient son nom et ses types de paramètres. Un problème d'ambiguïté survient lorsque deux des constructeurs de classe ont une signature identique.
Le compilateur ne parvient pas à différencier les deux et renvoie donc une notification d'erreur. Lorsque des constructeurs avec des signatures différentes sont surchargés, le compilateur détermine le constructeur à appeler en fonction du nombre de paramètres d'entrée des objets.
Utilisation de la surcharge du constructeur
Comme la surcharge de construction permet la création de l'objet d'une classe spécifique de plusieurs manières, elle est le plus souvent utilisée dans les programmes Java en fonction des besoins du programmeur. Avec l'utilisation de la surcharge du constructeur, les objets peuvent être initialisés avec différents types de données.
Considérez qu'un objet avec trois variables d'instance de classe est pris comme exemple où une valeur particulière doit être affectée à la deuxième variable d'instance et les autres variables doivent être affectées de valeurs par défaut. Cela peut être accompli par la déclaration de plusieurs constructeurs en fonction des différentes signatures de la classe constituante.
Lire : Explication des composants et de l'architecture de carrière Java
Exemple de code pour l'implémentation de la surcharge de constructeurs en Java
Considérons un programme dans lequel une classe Employee a trois constructeurs. En fonction des valeurs passées, chacun des trois est appelé pour initialiser un objet.
Utilisation de cette référence en Java
Toutes les méthodes d'instance et les constructeurs acceptent un paramètre implicite appelé 'this', qui est utilisé pour faire référence à l'objet courant. L'objet courant est l'objet sur lequel la méthode est invoquée. Nous pouvons utiliser la référence 'this' pour faire référence à l'objet actuel dans n'importe quel constructeur ou méthode. La référence 'this' peut être utilisée, comme toute autre référence d'objet, pour accéder aux méthodes d'instance, aux constructeurs et aux variables, dans le corps de la méthode ou du constructeur.
Peu de scénarios importants où la référence "this" est utilisée sont :
- Lorsque les noms des paramètres sont différents des noms des variables d'instance
- Lorsqu'une référence doit être passée à l'objet courant et un paramètre à une autre méthode
- Lorsqu'un constructeur doit être appelé à partir d'un autre constructeur.
Les arguments de référence this() doivent correspondre aux arguments du constructeur cible dans ce cas. La fonction this() doit être la première instruction du constructeur. Dans des cas particuliers tels que la complexité de la routine d'initialisation, cette fonction peut être utilisée dans l'élimination du code en double dans plusieurs constructeurs.
Apprenez des cours de développement de logiciels en ligne dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.
Avantages de la surcharge des constructeurs en Java
Les principaux avantages de l'utilisation de la surcharge du constructeur lors de l'écriture de programmes Java sont :
- La surcharge du constructeur permet la réalisation du polymorphisme statique.
- Les instances de classe peuvent être initialisées de plusieurs manières avec l'utilisation de la surcharge du constructeur.
- Il facilite le processus de définition de plusieurs constructeurs dans une classe avec des signatures uniques.
- Chaque constructeur surchargé effectue diverses tâches à des fins spécifiées.
Sommaire
- La surcharge de constructeur en Java fait référence à l'utilisation de plusieurs constructeurs dans une classe d'instance. Cependant, chaque constructeur surchargé doit avoir des signatures différentes.
- Pour que la compilation réussisse, chaque constructeur doit contenir une liste d'arguments différente.
- La liste des paramètres comprend la séquence et les types d'arguments d'entrée.
- Deux constructeurs dans une classe avec la même liste de paramètres ne sont pas réalisables en Java.
Si vous souhaitez en savoir plus sur le développement de logiciels à pile complète, consultez le programme exécutif PG de upGrad & IIIT-B en développement de logiciels - Spécialisation en développement de pile complète qui est conçu pour les professionnels en activité et offre plus de 500 heures de formation rigoureuse, 9+ projets et affectations, statut d'ancien de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.
