Tutoriel de constructeur Java

L'outil de constructeur est une méthode très importante et utile utilisée pour la programmation orientée objet. Il n'est pas obligatoire de déclarer un constructeur pour une classe, et cet outil est principalement utilisé pour initialiser l'objet de la classe au moment de la création d'objets. Le constructeur ne fonctionne pas comme d'autres méthodes normales. L'outil de constructeur est plutôt appelé automatiquement lorsqu'un objet est déclaré, et il répartit l'emplacement de la mémoire pour l'objet. Ce tutoriel vous montrera comment différents types de constructeurs définis par l'utilisateur peuvent être implémentés et utilisés dans la programmation de la classe Java.

Caractéristiques du constructeur

1. Le nom du constructeur doit être le même que le nom de classe.
2. Le type de retour est vide.
3. Le constructeur ne peut pas être statique, abstrait et final.

Types de constructeur

1. Défaut
2. Paramètre sans paramètre
3. Paramétré

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 de constructeur par défaut est créé au moment de la compilation du code Java et est stocké dans le .classe déposer.

Constructeur sans paramètre

Lorsqu'un constructeur est déclaré sans paramètre ni argument, alors il est appelé un 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.

Constructeur paramétré

Lorsqu'un constructeur est déclaré avec un ou plusieurs paramètres, il est appelé un constructeur paramétré. Les valeurs des paramètres du constructeur sont passées au moment de la création d'objets.

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 classe. Ici, le nom de classe est 'con1,«Ainsi, 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 d'objet 'obj,'Le constructeur sera appelé et un message particulier sera imprimé. Après cela, deux valeurs sont attribuées dans les variables de classe et sont imprimées ultérieurement en utilisant le 'Obj' objet.

classe publique Con1
// Déclarer les variables
Nom de chaîne;
en âge;
// Constructeur sans paramètre
con1 ()
Système.dehors.println ("Le constructeur est appelé.");
// initialise les variables
name = "Fahim Reza";
âge = 30;

// méthode main ()
public static void main (String [] args)
// Créer un objet
CON1 OBJ = NOUVEAU CON1 ();
// 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 d'objets et du message "Le constructeur est appelé"Est imprimé. Les valeurs de 'nom' et 'âge'sont affectés à l'intérieur du constructeur. Les valeurs de ces variables sont imprimées plus tard.

Exemple 2: Créer un constructeur paramétré

Le code suivant calculera le salaire total d'un employé en fonction du salaire de base et imprimera les autres informations de cet employé parallèlement au 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 'poste'Paramètres, et le troisième paramètre prendra la valeur numérique dans le'basique'paramètre. Les valeurs de ces paramètres seront transmises au moment de la création d'objets. Le constructeur initialisera les variables de classe avec ces valeurs et calculera les autres valeurs en fonction de la valeur du 'basique'paramètre. Ensuite, le nom, le poste et le salaire de l'employé seront imprimés.

classe publique Con2
// Déclarer les variables
Nom de chaîne;
Poste de chaîne;
int basic;
Double Houserent;
double médical;
double transport;
double salaire;
// Constructeur paramétré
con2 (nom de chaîne, couronne de chaîne, int basique)
ce.name = name;
ce.Post = Post;
ce.Basic = Basic;
ce.Houserent = basique * 0.3;
ce.Medical = Basic * 0.2;
ce.Transport = Basic * 0.1;
Salaire = Basic + Houserent + Medical + Transport;

// méthode main ()
public static void main (String [] args)
// Créer un objet
CON2 OBJ = NOUVEAU CON2 ("Mir Sabbir", "comptable", 65000);
// imprime les valeurs des propriétés de l'objet
Système.dehors.Print ("Nom de l'employé:" + OBJ.Nom + "\ n" + "Post:" + obj.poste +
"\ n" + "salaire: tk" + obj.Salaire);

Sortir:

L'image suivante montre la sortie du code. Ici, le nom, le poste et le salaire de base de l'employé sont donnés dans la déclaration de la création d'objets. Le salaire total, le nom et le message sont imprimés ici.

Exemple 3: Créer un chaînage de constructeur

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 constructeur. Lorsqu'une nouvelle classe est créée en héritant d'une autre classe, elle est appelée héritage. Dans ce cas, toutes les propriétés du parent ou de la classe de base sont accessibles depuis l'enfant ou la classe 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. Le 'super()'La méthode est utilisée dans d'autres langues pour appeler le constructeur parent, mais le compilateur Java appelle automatiquement cette méthode. L'utilisation de constructeurs de cette manière est appelée chaînage de constructeurs, et ce processus est montré dans cet exemple. Ici, le nom de la classe parent est 'parent'Et le nom de classe infantile est'con3.'Il y a une autre méthode nommée'combiner()'Dans la classe d'enfants qui combine les valeurs attribuées dans les constructeurs parent et enfants.

classe parent
// Déclarer la variable
String strVal;
// Constructeur parent
parent()
Système.dehors.println ("Le constructeur parent est appelé");
strval = "j'aime";


La classe publique Con3 étend le parent
// Déclarer la variable
String ChildstrVal;
// Constructeur d'enfants
con3 ()
Système.dehors.println ("Le constructeur enfant est appelé");
childstrVal = strval + "programmation java";

// une autre méthode pour combiner des chaînes
String combine ()

retourner ceci.Childstrval;

// méthode main ()
public static void main (String [] args)
// Créer un objet
con3 obj = new con3 ();
// 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 de différents constructeurs sont expliqués dans ce tutoriel en utilisant des exemples de code Java Easy pour ce novice que les utilisateurs peuvent suivre. Espérons que ces exemples vous ont aidé à comprendre les bases du constructeur Java.