Constructeur Java
En Java, un constructeur est une méthode particulière d'initialisation d'objets. Lorsqu'un objet de classe est formé, le constructeur est appelé. Il est possible de l'utiliser pour définir les valeurs par défaut des attributs d'objet comme suit :
// Creating the Main class in Java
public class JavaConstructor {
String a;
// Creating a class constructor for the Main class
public JavaConstructor() {
a = "I am the constructor";
}
public static void main(String[] args) {
JavaConstructor objInstance = new JavaConstructor();
System.out.println(objInstance.a);
}
} Il convient de noter que le nom du constructeur doit être le même que le nom de la classe et qu'il ne peut pas avoir de type de retour (comme void). De plus, lorsqu'un objet est créé, le constructeur est appelé. Par défaut, toutes les classes ont des constructeurs ; si vous n'en créez pas vous-même, Java le fera pour vous. Cependant, vous ne pourrez pas spécifier de valeurs initiales pour les propriétés de l'objet dans ce cas.
Paramètres pour les constructeurs
Les constructeurs peuvent également accepter des arguments, qui sont utilisés pour configurer des attributs. Le constructeur est étendu avec un paramètre int a dans l'exemple ci-dessous. Nous définissons a sur b (a=b) à l'intérieur du constructeur. Nous fournissons un argument de (10) au constructeur lorsque nous l'appelons, et il définit la valeur de sur 10 :
public class JavaConstructor {
int a;
public JavaConstructor(int b) {
a = b;
}
public static void main(String[] args) {
JavaConstructor objInstance;= new JavaConstructor(10);
System.out.println(objInstance.a);
}
} Vous êtes libre d'utiliser autant de paramètres que vous le souhaitez :
//filename: JavaConstructor.java
public class JavaConstructor {
int modelYear;
String modelName;
public JavaConstructor(int year, String name) {
modelYear = year;
modelName = name;
}
public static void main(String[] args) {
JavaConstructor myCar = new JavaConstructor(2020, "Sedan");
System.out.println(myCar.modelYear + " " + myCar.modelName);
}
} Les règles régissent le constructeur en Java. Ces règles d'écriture d'un constructeur Java sont les suivantes :
- Le nom du constructeur doit correspondre au nom de la classe.
- Il ne doit y avoir aucun type de retour explicite dans un constructeur.
- Un constructeur Java abstrait, statique, final et synchronisé est impossible.
Types de constructeurs en Java
Les constructeurs Java se présentent sous différentes formes et tailles. En Java, il existe deux types de constructeurs :
- Un constructeur par défaut (constructeur sans argument)
- Constructeur avec paramètres
Constructeur par défaut en Java
Lorsqu'un constructeur n'a pas de paramètres, il est appelé le "constructeur par défaut". Le constructeur par défaut a la syntaxe suivante :
<class_name>(){} Exemple :Constructeur par défaut
Le constructeur sans argument de la classe defaultConstructor est créé dans cet exemple. Il sera appelé lors de la création de l'objet.
//Program creating and calling a default constructor
class defaultConstructor{
//creating a default constructor
defaultConstructor(){
System.out.println("This is the default constructor");
}
//main method
public static void main(String args[]){
//calling a default constructor
defaultConstructor b=new defaultConstructor();
}
} Si une classe n'a pas de constructeur, le compilateur en ajoute un automatiquement.
Quel est le but d'un constructeur par défaut ?
Le constructeur par défaut donne à l'objet des valeurs par défaut telles que 0, null, etc., selon le type. Un constructeur par défaut qui affiche les paramètres par défaut est un exemple.
// default constructor example
// show the default values
class Employee{
int id;
String firstName;
String lastName;
//method to display the value of id and name
void display(){System.out.println(id+" "+firstName+" "+lastName);}
public static void main(String args[]){
// object creation
Employee empOne=new Employee();
Employee empTwo=new Employee();
//displaying values of the object
empOne.display();
empTwo.display();
}
} Le compilateur en a créé un pour nous car nous n'avons pas créé de constructeur dans la classe ci-dessus. Le constructeur par défaut fournit des valeurs 0 et null dans ce cas.
Constructeur avec paramètres en Java
Un constructeur paramétré est un constructeur qui a un nombre défini de paramètres. Pourquoi voudriez-vous utiliser un constructeur paramétré ? Différentes valeurs sont affectées à d'autres objets à l'aide du constructeur paramétré. Vous pouvez cependant fournir les mêmes valeurs.
Exemple :Un constructeur paramétré
Nous avons développé un constructeur pour la classe Employee avec deux paramètres dans cet exemple. Le constructeur peut contenir n'importe quel nombre de paramètres.
//Program demonstrating the use of the parameterized constructor.
class Employee{
int id;
String firstName;
String lastName;
//creation of a parameterized constructor
Employee(int i,String fname, String lname){
id = i;
firstName; = fname;
lastName; = lname;
}
//method to display the values
void display(){System.out.println(id+" "+firstName+" "+lastName);}
public static void main(String args[]){
//creating objects and passing values
Employee empOne = new Employee(20,"Thomas","Keen");
Employee empTwo = new Employee(30,"Ann","Thompson");
//calling method to display the values of object
empOne.display();
empTwo.display();
}
} Surcharge du constructeur Java
Un constructeur est similaire à une méthode en Java, sauf qu'il n'a pas de type de retour. Tout comme les méthodes Java, il peut être surchargé.
En Java, la surcharge de constructeur fait référence à plusieurs constructeurs avec différentes listes de paramètres. Ils sont structurés de manière à ce que chaque constructeur fasse quelque chose de distinct. Le compilateur les distingue en fonction du nombre de paramètres dans la liste et de leurs types.
Exemple :surcharge d'un constructeur en Java
//Program illustrating constructor overloading
class Employee{
int id;
String firstName;
String lastName;
int age;
//creation of a two arg constructor
Employee(int i,String fname){
id = i;
firstName = fname;
}
//creation of a three arg constructor
Employee(int i,String fname, String lname){
id = i;
firstName = fname;
lastName = lname;
}
//creation of a four arg constructor
Employee(int i,String fname, String lname,int a){
id = i;
firstName = fname;
lastName = lname;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}
public static void main(String args[]){
Employee empOne = new Employee(20,"Ann");
Employee empTwo = new Employee(30,"Thomas","Saks");
Employee empThree = new Employee(40,"Jerry","Floyd", 49);
empOne.display();
empTwo.display();
empThree.display();
}
} Constructeur pour copier en Java
En Java, il n'y a pas de constructeur de copie. Cependant, en utilisant le constructeur de copie en C++, nous pouvons copier des valeurs d'un objet à un autre. En Java, il existe de nombreuses méthodes pour copier les valeurs d'un objet à un autre. Ils sont les suivants :
- Utilisation du constructeur
- En transférant les valeurs d'un objet à un autre, vous pouvez en créer un nouveau.
- Utilisation de la fonction clone() de la classe Object
Dans cet exemple, nous utiliserons le constructeur Java pour répliquer les valeurs d'un objet à un autre.
// program for initializing the values from one object to another object.
class Employee{
int id;
String firstName;
//constructor for initializing an integer and string
Employee(int i,String fname){
id = i;
firstName = fname;
}
//constructor to initialize another object
Employee(Employee empOne){
id = empOne.id;
firstName =empOne.firstName;
}
void display(){System.out.println(id+" "+firstName);}
public static void main(String args[]){
Employee empOne = new Employee(20,"Ann");
Employee empTwo = new Employee(empOne);
empOne.display();
empOne.display();
}
} Conclusion
La classe Constructor en Java est utilisée pour accéder aux informations internes du constructeur d'une classe. Le constructeur peut faire d'autres choses que l'initialisation, comme créer un objet, lancer un thread ou appeler une méthode. Dans le constructeur, vous pouvez exécuter n'importe quelle opération dans la méthode. Le package java.lang.reflect le contient.
Un constructeur en Java est un bloc de code comparable à une méthode. Lorsqu'une nouvelle instance de classe est créée, cette méthode est invoquée. La mémoire de l'objet est allouée lorsque le constructeur est appelé.
C'est un type spécifique de méthode qui est utilisé pour configurer un objet. Au moins un constructeur est appelé chaque fois qu'un objet est créé avec le mot-clé new(). Dans ce scénario, le compilateur Java crée automatiquement un constructeur par défaut. Si aucun constructeur n'est disponible dans la classe, il utilise le constructeur par défaut. Il existe deux types de constructeurs en Java :les constructeurs sans argument et paramétrés.
