Caractéristiques du constructeur
- Le nom du constructeur doit être le même que le nom de la classe.
- Le type de retour est nul.
- Le constructeur ne peut pas être statique, abstrait et final.
Types de constructeur
- Défaut
- Sans paramètre
- Paramétré
1. Constructeur par défaut
Le constructeur par défaut est créé par le compilateur Java lorsque le codeur ne déclare aucun constructeur pour la classe et que ce constructeur ne contient aucun argument. Le fichier Java ne contient aucun code pour le constructeur par défaut. Le code constructeur par défaut est créé au moment de la compilation du code Java et est stocké dans le .classer déposer.
2. Constructeur sans paramètre
Lorsqu'un constructeur est déclaré sans paramètre ni argument, il est alors appelé constructeur sans paramètre. Un constructeur sans paramètre fonctionne comme un constructeur par défaut et ce constructeur peut contenir des instructions, ou il peut être vide.
3. Constructeur paramétré
Lorsqu'un constructeur est déclaré avec un ou plusieurs paramètres, il est alors appelé constructeur paramétré. Les valeurs des paramètres du constructeur sont transmises au moment de la création de l'objet.
Exemple 1 : création d'un constructeur sans paramètre
Le code suivant montre comment utiliser un constructeur sans paramètre. Il a été mentionné précédemment que le nom de la méthode du constructeur sera le même que le nom de la classe. Ici, le nom de la classe est ' con1 ,’ donc le nom du constructeur sans paramètre est ‘ con1() .’ Deux variables de classe, ‘ Nom ' et ' âge ,' sont déclarés ici. Au moment de déclarer la variable objet ‘ obj ,’ le constructeur sera appelé et un message particulier sera affiché. Après cela, deux valeurs sont affectées dans les variables de classe et sont imprimées plus tard en utilisant le « Obj » objet.
Publique classercon1{// déclarer des variables
Chaîne de caractères Nom;
entierâge;
//Constructeur sans paramètre
con1() {
Système .dehors.imprimer('Le constructeur est appelé.');
//Initialisation des variables
Nom= 'Fahim Reza';
âge= 30;
}
// méthode principale ()
Publique statique annulerprincipale( Chaîne de caractères []arguments) {
//Créer un objet
con1 obj= Nouveaucon1();
//Imprime les valeurs des propriétés de l'objet
Système .dehors.imprimer('L'âge de ' +obj.Nom + ' est ' +obj.âge);
}
}
Sortir:
L'image suivante montre la sortie du code. Le constructeur est appelé au moment de la création de l'objet et le message Le constructeur s'appelle est imprimé. Les valeurs de ‘ Nom ' et ' âge ' sont affectés à l'intérieur du constructeur. Les valeurs de ces variables sont imprimées ultérieurement.
Exemple 2 : créer un constructeur paramétré
Le code suivant calculera le salaire total d'un employé sur la base du salaire de base et imprimera les autres informations de cet employé à côté du salaire calculé. Ici, sept variables de classe sont déclarées. Le constructeur, nommé ' con2() ,’ a trois paramètres. Les deux premiers paramètres prendront les valeurs de chaîne dans le ' Nom ' et ' Publier ’ paramètres, et le troisième paramètre prendra la valeur numérique dans le ‘ de base ’ paramètre. Les valeurs de ces paramètres seront transmises au moment de la création de l'objet. Le constructeur initialisera les variables de classe avec ces valeurs et calculera les autres valeurs en fonction de la valeur du ' de base ’ paramètre. Ensuite, le nom, le poste et le salaire de l'employé seront imprimés.
Publique classercon2{// Déclarer des variables
Chaîne de caractères Nom;
Chaîne de caractères Publier;
entierDe base;
doubleLocation de maison;
doubleMédical;
doubleTransport;
doubleUn salaire;
//Constructeur paramétré
con2( Chaîne de caractères Nom, Chaîne de caractères Publier,entierde base) {
cette.Nom =Nom;
cette.Publier =Publier;
cette.De base =de base;
cette.Location de maison =de base*0,3;
cette.Médical =de base*0,2;
cette.Transport =de base*0,1;
Un salaire=de base+Location de maison+Médical+Transport;
}
// méthode principale ()
Publique statique annulerprincipale( Chaîne de caractères []arguments) {
//Créer un objet
con2 obj= Nouveaucon2('Mir Sabbir','Comptable',65000);
//Imprime les valeurs des propriétés de l'objet
Système .dehors.imprimer('Nom de l'employé: ' +obj.Nom + ' ' + 'Poster: '+obj.Publier +
' ' + « Salaire : TK »+obj.Un salaire);
}
}
Sortir:
L'image suivante montre la sortie du code. Ici, le nom, le poste et le salaire de base du salarié sont indiqués dans la déclaration de création de l'objet. Le salaire total, le nom et le poste sont imprimés ici.
Exemple 3 : Créer un chaînage de constructeurs
Il est important de connaître la fonction d'héritage de la programmation orientée objet pour comprendre le concept de chaînage de constructeurs. Lorsqu'une nouvelle classe est créée en héritant d'une autre classe, on parle d'héritage. Dans ce cas, toutes les propriétés de la classe parent ou de base sont accessibles à partir de la classe enfant ou dérivée. Lorsqu'un objet de la classe enfant est créé, il appelle automatiquement le constructeur de la classe parent avant d'appeler son propre constructeur. Les ' super() ’ est utilisée dans d'autres langages pour appeler le constructeur parent, mais le compilateur Java appelle cette méthode automatiquement. L'utilisation de constructeurs de cette manière est appelée chaînage de constructeurs, et ce processus est illustré dans cet exemple. Ici, le nom de la classe parent est ' parent ' et le nom de la classe enfant est ' con3 .’ Il existe une autre méthode nommée ‘ combiner() ’ dans la classe enfant qui combine les valeurs affectées dans les constructeurs parent et enfant.
classerparent{// Déclare la variable
Chaîne de caractères strVal;
//Constructeur parent
parent(){
Système .dehors.imprimer(« Le constructeur parent est appelé »);
strVal= 'J'apprécie ';
}
}
Publique classercon3s'étendparent{
// Déclare la variable
Chaîne de caractères enfantStrVal;
//Constructeur enfant
con3(){
Système .dehors.imprimer(« Le constructeur de l'enfant s'appelle »);
enfantStrVal=strVal+ 'Programmation Java';
}
//Une autre méthode pour combiner des chaînes
Chaîne de caractères combiner()
{
revenir cette.enfantStrVal;
}
// méthode principale ()
Publique statique annulerprincipale( Chaîne de caractères []arguments) {
//Créer un objet
con3 obj= Nouveaucon3();
//Imprime les valeurs des propriétés de l'objet
Système .dehors.imprimer(obj.combiner());
}
}
Sortir:
L'image suivante montre la sortie du code. Le premier message est imprimé à partir du constructeur parent, tandis que le deuxième message est imprimé à partir du constructeur enfant. Le dernier message est imprimé en appelant le ' combiner() ' méthode.
Conclusion
Le concept du constructeur et les utilisations des différents constructeurs sont expliqués dans ce didacticiel à l'aide d'exemples de code Java simples que les utilisateurs novices peuvent suivre. Espérons que ces exemples vous ont aidé à comprendre les bases du constructeur Java.