Introduction à Constructor en Java
Les constructeurs en Java sont des types spéciaux de méthodes qui sont utilisées pour initialiser les objets de la classe. Les constructeurs sont appelés au moment de la création d'objet de la classe. Tout comme les méthodes, bien qu'elles contiennent un ensemble de lignes de code, elles sont très différentes d'elles. Les constructeurs ont le même nom que la classe Java mais elle n'a aucun type de retour. En Java, un nouveau mot-clé () à utiliser pour créer un objet et chaque fois qu'un nouvel objet est créé et qu'un constructeur est appelé. Le constructeur est appelé après que la mémoire est allouée à l'objet. Au moment de la création de l'objet, les constructeurs sont habitués à initialiser les valeurs des variables de classe sur celles par défaut ou celles souhaitées.
Si l'utilisateur ne crée aucun constructeur dans le programme, Java lui-même crée un constructeur par défaut pour lui et attribue des valeurs par défaut aux différents objets comme pour la valeur numérique par défaut est 0, pour un caractère ('\ 0') et les variables de référence comme nulles . Comme les méthodes, les constructeurs peuvent être surchargés, c'est-à-dire qu'une seule classe peut avoir plusieurs constructeurs si tous ont une signature unique.
La syntaxe de base de Constructor en Java est donnée ci-dessous:
Syntaxe
public class Student() // name of the class
(
. . . .
. . . .
. . . .
Student() // this is Constructor with the same name of class
(
. . .
. . .
)
new Student(); // object creation and value initialization
)
Dans la syntaxe ci-dessus, Student () est le nom du constructeur qui est le même que le nom de la classe et les objets en Java sont créés en utilisant le mot-clé new.
Comment fonctionne Constructor en Java?
Pour comprendre le fonctionnement des constructeurs en Java, prenons un exemple donné ci-dessous:
Code
public class Student()
(
int rollno;
String name;
Student(int rollno, String name)
(
this.rollno = rollno;
this.name = name;
)
public static void main(String() args)
(
Student st = new Student(12, 'Ananya');
System.out.println(“Student name = ”+ st.name + “Student rollno = ”+st.rollno);
)
)
Production
Dans l'exemple ci-dessus, nous avons des variables d'instance (variables de classe). Roll no et name and st Est le nom de l'objet créé de la classe Student. Lorsque l'objet st est créé, il invoque le constructeur Student et initialise les variables de classe avec la valeur rollno comme 12 et le nom comme 'Ananya' sinon les valeurs par défaut comme 0 pour rollno et null pour le nom seront assignées aux variables. Par conséquent, après avoir attribué les valeurs et les avoir imprimées, le nom de l'élève est imprimé comme Ananya et l'élève rollno comme 12.
Types de constructeurs en Java
Il existe 2 types de constructeurs en Java basés sur des paramètres:
1. Constructeur non paramétré / sans arguments
Lorsque nous ne passons pas d'arguments dans le constructeur, ce constructeur est connu comme un constructeur non paramétré ou sans argument. Lorsque le programmeur ne définit aucun constructeur dans le programme Java, le compilateur Java lui-même y ajoute un constructeur, appelé constructeur par défaut qui fournit des valeurs par défaut à l'objet comme 0, null, etc. Le constructeur par défaut n'est pas un type spécial de constructeur mais tombe dans la catégorie des constructeurs sans arguments.
Exemple (constructeur par défaut)
Code
public class Hello()
(
String name;
void display() //method to display name the value of variables
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Production:
Dans l'exemple ci-dessus, ce n'est pas un constructeur défini par le programmeur, donc le compilateur traitera ce programme comme:
Code
public class Hello()
(
String name;
Hello() //default constructor created by compiler
(
name = null
)
void display()
(
System.out.println(“name is” +name);
)
)
public class HelloMain()
(
public static void main(String() args)
(
Hello h1 = new Hello();
h1.display();
)
)
Exemple (constructeur non paramétré)
Code
public DemoProgram() // class
(
DemoProgram() // constructor with no arguments
(
System.out.println(“Hello this is just an example of no-arg constructor”);
)
public static void main(String() args)
(
new DermoProgram();
)
)
Production:
Comme dans l'exemple ci-dessus, pour le constructeur DemoProgram (), aucun argument n'est passé, seul le message est imprimé et, par conséquent, il est appelé constructeur sans argument.
2. Constructeur paramétré
Les constructeurs paramétrés sont les constructeurs dans lesquels nous passons les arguments ou les paramètres. Dans ce constructeur, les valeurs sont transmises au moment de la création de l'objet.
Exemple (constructeurs paramétrés)
Code
public class Animal()
(
int legs;
String sound;
Animal(int legs, String sound) // parameterized constructor
(
this.legs = legs; // values with get initialize of what is passed while object crea-this.sound = sound; // tion, ie (4, “bow bow”)
)
void display() // method to display the values
(
System.out.println(“Legs are ”+legs+“Sound is ”+sound);
)
)
class AnimalPlanet()
(
Public static void main(String() args)
(
Animal an = new Animal(4, “bow bow”);
an.display();
)
)
Production:
Dans l'exemple ci-dessus, la valeur 4 est affectée aux jambes et la corde "bow bow" est affectée au son dans le constructeur Animal. Ainsi, lorsque l'affichage de la méthode est appelé, les deux valeurs sont imprimées dans la sortie.
Points importants à retenir
- Chaque classe a un constructeur, que le programmeur le crée ou non.
- Le nom du constructeur doit être le même que le nom de la classe.
- Le constructeur n'a pas de type de retour, contrairement aux méthodes.
- ce mot-clé () et super () doit être la première instruction d'un constructeur.
- Comme les méthodes, les constructeurs peuvent être surchargés.
- Les constructeurs ne peuvent pas être remplacés.
- Un constructeur peut invoquer un autre constructeur de la même classe en utilisant le mot-clé this ().
- Les spécificateurs / modificateurs d'accès peuvent être appliqués avant le nom du constructeur pour en déclarer la portée dans une classe.
- En Java, un constructeur ne peut jamais être statique, final, abstrait et synchronisé.
Conclusion
Les constructeurs jouent un rôle important lorsqu'il s'agit de travailler avec le langage de programmation Java. Il faut avoir besoin de comprendre les concepts complets du constructeur, les différents types de constructeurs, le chaînage des constructeurs, le mot-clé super () utilisé pour appeler le constructeur parent pour travailler selon le scénario spécifique. Bien que travailler avec des constructeurs en Java soit très facile comme travailler avec des méthodes, il y a peu de points spécifiques aux constructeurs qui devraient être approfondis.
Article recommandé
Ceci est un guide du constructeur en java. Nous discutons ici du fonctionnement du constructeur en java ainsi que des types et des exemples avec l'implémentation de code appropriée. vous pouvez également parcourir nos articles suggérés pour en savoir plus-
- Constructeur en JavaScript et types
- Introduction à Constructor en Python
- Constructeur en C ++ et types
- Constructeur en PHP (Exemples)