Chaînage de constructeurs en Java avec exemples et implémentation

En Java, les constructeurs peuvent être compris comme des blocs de code utilisés pour initialiser des objets nouvellement créés. Un constructeur est similaire aux méthodes d'instance en Java. Cependant, il existe une différence cruciale entre les constructeurs et les méthodes en Java - alors que les méthodes ont un type de retour, les constructeurs n'ont pas de type de retour spécifique. Les programmeurs se réfèrent souvent aux constructeurs comme un type spécial de méthode en Java.

Les constructeurs en Java portent le même nom que la classe et ressemblent à ceci :

classe publique monProgramme{

// C'est le constructeur

monProgramme(){

}

..

}

Lorsqu'un constructeur est appelé depuis un autre constructeur, c'est à ce moment que le chaînage de constructeurs se produit en Java. Cependant, avant de plonger plus profondément dans le chaînage de constructeurs, examinons d'abord rapidement le fonctionnement des constructeurs en Java, ainsi que quelques exemples pour consolider votre compréhension.

Comment fonctionnent les constructeurs en Java ?

Pour comprendre le fonctionnement des constructeurs, regardons un exemple. Supposons que nous ayons une classe nommée myProgram. Maintenant, lorsque nous créerons l'objet de cette classe, nous devrons écrire l'instruction suivante :

monProgramme obj = new monProgramme()

Comme vous pouvez le voir, le nouveau mot-clé utilisé dans l'exemple ci-dessus crée l'objet de myProgram et appelle un constructeur pour initialiser cet objet nouvellement créé.

Si cela vous semble un peu déroutant, ne vous inquiétez pas. Regardons un programme constructeur simple en Java pour mieux comprendre le fonctionnement des constructeurs en Java.

Programme constructeur de base en Java

Regardez le morceau de code Java suivant qui utilise des constructeurs :

Test de classe publique{

Livre à cordes;

//Constructeur

Test(){

this.book = "Un receveur dans le seigle" ;

}

public static void main(String[] args) {

Test obj = nouveau Test();

System.out.println(obj.book);

}

}

Sortir:

Un receveur dans le seigle

Dans le programme ci-dessus, nous avons créé un objet nommé 'obj' de notre classe Program. Ensuite, nous avons imprimé le nom de la variable d'instance de cet objet nouvellement créé. Comme vous pouvez le voir sur la sortie, la sortie est la même que la valeur passée à 'book' lors de l'initialisation du constructeur.

Ce que cela montre, c'est qu'au moment où l'objet obj a été créé, le constructeur a été automatiquement invoqué. Ici, nous avons utilisé le mot clé 'this' pour faire référence à l'objet courant. Il existe également d'autres façons de le faire, dont nous parlerons plus tard dans l'article lors de la discussion sur le chaînage des constructeurs.

Une fois les bases de Constructor en Java établies, passons au chaînage de constructeurs en Java et à son fonctionnement !

Chaînage de constructeurs au sein d'une même classe

Maisqu'est-ce que le chaînage de constructeurs en Java impliquant une seule classe ?L'appel d'un constructeur à partir d'un autre dans la même classe inclut le chaînage des constructeurs au sein de cette classe. Le mot-clé "this" est utilisé dans la syntaxe pour le chaînage des constructeurs au sein d'une même classe. L'instance de classe actuelle est référencée lorsque "this" est utilisé. Il est préférable de comprendre l'utilisation duchaînage de constructeurs en Java avec example .

Chaînage de constructeurs à partir de classes de base/parentes

Une classe en Java peut dériver d'une autre classe ; la classe dérivée est appelée sous-classe et la classe dont elle dérive est appelée superclasse. Une sous-classe peut avoir ses propres constructeurs et invoquer ceux de sa super-classe.

Un constructeur de superclasse utilise le terme super(), suivi des entrées requises. Le mot-clé super() doit toujours être présent dans la première ligne du constructeur de la sous-classe.

Appel depuis un constructeur différent, un constructeur

En utilisant le mot-clé this(), un constructeur en Java peut appeler un autre constructeur de la même classe. Le premier mot-clé du constructeur doit toujours être le mot-clé this(), qui ne peut être utilisé que pour appeler un autre constructeur du même type.

Constructeur de superclasse téléphonique

Le mot clé super() en Java permet aux constructeurs de sous-classes d'appeler le constructeur de la superclasse. Le mot clé super(), qui ne peut être utilisé que pour appeler le constructeur de la superclasse de la sous-classe, doit toujours être la première ligne du constructeur de la sous-classe.

Les programmes Java peuvent se comporter différemment si les constructeurs sont organisés dans un ordre différent. Si une classe a plusieurs constructeurs et que l'un d'eux utilise le mot clé this() pour appeler un autre constructeur, la modification de l'ordre des constructeurs peut modifier le comportement d'un programme.

Une autre façon de chaîner les constructeurs à l'aide du bloc Init

L'utilisation d'un bloc d'initialisation est une autre approche du chaînage de constructeurs en Java .Une section de code connue sous le nom de bloc d'initialisation s'exécute

L'essentiel du chaînage de constructeurs en Java

Lorsque nous appelons un constructeur à partir d'un autre constructeur de la même classe, ce qui se passe est connu sous le nom de chaînage de constructeurs. Le but principal du chaînage de constructeurs est de passer des paramètres à travers un tas de constructeurs différents et de ne les initialiser qu'à un seul endroit. De cette façon, vous avez la possibilité de conserver toutes vos initialisations en un seul endroit tandis que différents constructeurs peuvent être fournis aux utilisateurs.

Si vous n'effectuez pas de chaînage de constructeurs et que deux constructeurs différents nécessitent un paramètre, vous devrez initialiser ce paramètre deux fois. De plus, chaque fois que l'initialisation change, vous devrez apporter des modifications respectives à tous les constructeurs au lieu d'un seul.

En règle générale, vous devez toujours appeler des constructeurs avec plus d'arguments à partir de constructeurs qui ont moins d'arguments. Vous devez également savoir que nous pouvons surcharger plusieurs constructeurs dans la classe. Cependant, au moment où un objet est créé, un seul constructeur particulier est appelé. Il peut y avoir plusieurs situations lors de la programmation en Java où vous auriez besoin d'appeler plusieurs constructeurs les uns des autres sans créer d'objets différents. Ce mécanisme d'appel d'un constructeur à partir d'un autre constructeur et lorsque ce constructeur impliqué appelle un autre constructeur est connu sous le nom de chaînage de constructeurs.

Apprenezdes cours de logicielsen 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.

Il y a deux choses principales que vous devez garder à l'esprit concernant le chaînage des constructeurs pour garantir une clarté maximale :

• L'objectif principal du chaînage de constructeurs est de maintenir le code. L'idée est de vous aider à écrire un seul morceau de code qui peut être réutilisé dans votre programme. De cette façon, non seulement votre code sera propre et lisible, mais il sera également beaucoup plus facile à gérer avec toutes les corrections et modifications apportées à un seul endroit au lieu de tous les constructeurs.
• Le constructeur qui a été appelé ne crée pas d'objet séparé. Au lieu de cela, il utilise l'objet en cours d'exécution pour appeler un autre constructeur. C'est comme appeler une méthode différente à l'intérieur de votre constructeur, sauf que c'est aussi un constructeur.

Comme vous l'avez vu dans l'exemple précédent, nous avons utilisé ce mot clé pour accéder aux paramètres du constructeur. De même, Constructor Chaining nécessite également principalement deux mots-clés. Voici ces deux mots clés :

• this – Sa représentation de méthode appelle un constructeur de classe actuel.
• super - Sa représentation de méthode appelle un constructeur immédiat de super ou de superclasse parent.

De plus, vous devez connaître quelques autres termes et définitions importants en termes de chaînage de constructeurs en Java :

• Invocation de constructeur : lorsque vous invoquez un constructeur et que ce constructeur est appelé avec succès, il est appelé Invocation de constructeur.
• Exécution du constructeur : si lors de l'appel du constructeur, le contrôle commence à exécuter les instructions dans le corps du constructeur. C'est ce qu'on appelle l'exécution du constructeur.

Règles clés du chaînage de constructeurs en Java

Une fois les bases du chaînage de constructeurs établies, examinons quelques règles essentielles pour travailler avec le chaînage de constructeurs en Java :

• this() ne peut appeler que les paramètres appartenant au même constructeur.
• super() ne peut appeler que le Constructeur de la superclasse immédiate.
• this() et super() doivent être la première instruction du constructeur.
• Ceci () et super() ne peuvent pas être utilisés dans le même constructeur car les deux individus doivent être les premières déclarations, ce qui n'est pratiquement pas possible.
• Vous ne pouvez pas ajouter this() dans tous les constructeurs de la même classe, car il devrait y avoir au moins un constructeur sans cette instruction().
• L'invocation et l'exécution des constructeurs en Java se produisent de manière opposée. Ainsi, si les constructeurs ont été appelés dans l'ordre A, B, C, alors l'exécution se fera dans l'ordre C, B, A.

Par exemple, ici, nous avons deux classes distinctes qui fonctionnent en surchargeant différents constructeurs. Nous voulons exécuter les constructeurs dans l'ordre 2, 1, 4, 3, 5.

Pour exécuter les constructeurs dans l'ordre, nous devons appeler les constructeurs exactement dans l'ordre opposé comme 5, 3, 4, 1, 2, voir dans l'exemple ci-dessous.

Parent de classe

{

Parent()// 1

{

ceci ("bonjour");

System.out.println("dans Parent 0 arg constructeur 1");

}

Parent(Chaîne msg)// 2

{

System.out.println("dans le constructeur Parent (String) 2");

}

}

Le constructeur de la classe étend le parent

{

Constructeur()// 3

{

this(10);//appelant le constructeur à 5 chiffres

System.out.println("dans Constructeur 0 arg constructeur 3");

}

Constructeur(String msg)// 4

{

super();//appelant le constructeur de la classe parent numéro 1

System.out.println(“in Constructor(String msg) arg constructor 4”);

}

Constructeur(int i)// 5

{

this("hello");//appelant le constructeur à 4 chiffres

System.out.println("in Constructor(int i) constructeur 5");

}

// méthode main()

public static void main(String[] args)

{

Constructeur cobj = new Constructor(); // appelant le constructeur à 3 nombres

}

}

Sortir:

dans le constructeur Parent(String) 2

in Parent 0 arg constructeur 1

in Constructor(String msg) arg constructeur 4

in Constructor(int i) constructeur 5

in Constructeur 0 arg constructeur 3

Résumant tous les concepts de constructeurs et de chaînage de constructeurs en Java avec un dernier exemple :

classe emp

{

public Chaîne EName ;

public int EEearnings;

adresse de chaîne publique ;

publicEmp()

{

ceci ("Rahul");

}

public Emp(nom de la chaîne)

{

this(nom, 140035);

}

public Emp(String name, int sal)

{

this(nom, sal, "New Delhi");

}

public Employee(String name, int sal, String add)

{

this.EName=nom ;

this.EEarnings=sal ;

cette.adresse=ajouter ;

}

void disp() {

System.out.println(“Nom : “+EName);

System.out.println("Salaire : "+EEgains );

System.out.println("Adresse : "+adresse);

}

public static void main(String[] args)

{

Employé obj = nouvel Employé();

obj.disp();

}

}

Sortir:

Nom de l'employé : Rahul

Salaire de l'employé : 140035

Adresse de l'employé : New Delhi

Conclusion

Sur ce, nous arrivons à la fin de cet article. Nous espérons que cela a clarifié vos doutes sur le chaînage de constructeurs en Java et renforcé votre compréhension. Chez upGrad, nous croyons qu'il est important d'aider les étudiants du monde entier à atteindre leur plein potentiel et à réussir dans leur carrière. Nos cours sont conçus en gardant à l'esprit les débutants et les professionnels expérimentés.

L'un de ces cours est la certification PG liée à l'emploi d'upGrad en génie logiciel , spécialement conçue pour les nouveaux demandeurs d'emploi. Découvrez le contenu du cours et inscrivez-vous dès aujourd'hui ! Apprenez toutes les compétences pertinentes en génie logiciel telles que Java, DSA, OODAP, JavaScript, MERN, AWS, etc., auprès d'experts du secteur et de professionnels de premier plan.