Constructeur en Java

Les constructeurs en Java sont des types spéciaux de méthodes utilisées pour initialiser les objets de la classe. Les constructeurs sont appelés au moment de la création de l'objet de la classe. Tout comme les méthodes, bien qu’elles contiennent un ensemble de lignes de code, elles en sont assez différentes. Les constructeurs ont le même nom que la classe Java, mais ils n'ont aucun type de retour. En Java, un mot-clé new() est utilisé pour créer un objet et chaque fois qu'un nouvel objet est créé et qu'un constructeur est appelé. Le constructeur est appelé une fois la mémoire allouée à l'objet. Au moment de la création de l'objet, les constructeurs sont utilisés pour initialiser les valeurs des variables de classe à 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 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 (' ') et des variables de référence comme nul. 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.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

La syntaxe de base du constructeur 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 à l'aide du mot-clé ​new.

Comment fonctionne le constructeur en Java ?

Pour comprendre le fonctionnement des constructeurs en Java, prenons un exemple 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);
}
}

Sortie :

Dans l'exemple ci-dessus, nous avons des variables d'instance (variables de classe). ​roll no ​et ​name et ​st ​Est le nom de l'objet créé de la classe Student. Lorsque l'objet est créé, il invoque le constructeur Student et initialise les variables de classe avec la valeur no de 12 et le nom « Ananya » ; sinon, les valeurs par défaut comme 0 pour rollno et null pour le nom seront attribuées aux variables. Par conséquent, après avoir attribué les valeurs et les avoir imprimées, le nom de l'étudiant est imprimé comme Ananya et le numéro de rôle de l'étudiant 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 transmettons pas d'arguments dans le constructeur, ce constructeur est appelé 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 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 entre 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();
}
}

Sortie :

Dans l'exemple ci-dessus, il ne s'agit pas d'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();
}
}

Sortie :

Comme dans l'exemple ci-dessus, pour le constructeur DemoProgram(), aucun argument n'est passé, seul le message est imprimé, et il est donc connu sous le nom de constructeur sans argument.

2. Constructeur paramétré​

Les constructeurs paramétrés sont les constructeurs dans lesquels nous transmettons 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, i.e. (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();
}
}

Sortie :

Dans l'exemple ci-dessus, la valeur 4 est attribuée aux jambes, et la corde « bow bow » est attribuée au son dans le constructeur Animal. Ainsi, lorsque la méthode display est appelée, 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.
• Les mots-clés this() et super() doivent ê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 déclarer sa 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 comprendre tous les concepts du constructeur, des différents types de constructeurs, du chaînage de constructeurs et du mot-clé super() utilisé pour appeler le constructeur parent pour qu'il fonctionne selon le scénario spécifique. Bien que travailler avec des constructeurs en Java soit très simple, comme travailler avec des méthodes, quelques points spécifiques doivent être appris en profondeur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!