Les constructeurs Java ou constructeurs en Java sont une terminologie utilisée pour construire quelque chose dans nos programmes. Un constructeur en Java est un méthode spéciale qui est utilisé pour initialiser les objets. Le constructeur est appelé lorsqu'un objet d'une classe est créé. Il peut être utilisé pour définir les valeurs initiales des attributs d'objet.

Que sont les constructeurs en Java ?

En Java, un Constructeur est un bloc de codes similaire à la méthode. Il est appelé lorsqu'une instance de la classe est créée. Au moment de l'appel du constructeur, la mémoire de l'objet est allouée dans la mémoire. Il s'agit d'un type spécial de méthode utilisée pour initialiser l'objet. Chaque fois qu'un objet est créé à l'aide du mot-clé new(), au moins un constructeur est appelé.

Exemple de constructeur Java

Vous trouverez ci-dessous l'implémentation des constructeurs Java :

// Java Program to demonstrate // Constructor import java.io.*; // Driver Class class Geeks {    // Constructor  Geeks()  {  super();  System.out.println('Constructor Called');  }  // main function  public static void main(String[] args)  {  Geeks geek = new Geeks();  } }>

Constructor Called>

Note: Il n’est pas nécessaire d’écrire un constructeur pour une classe. C'est parce que le compilateur Java crée un constructeur par défaut (constructeur sans arguments) si votre classe n'en a pas.

En quoi les constructeurs Java sont-ils différents des méthodes Java ?

• Les constructeurs doivent avoir le même nom que la classe dans laquelle ils sont définis, ce n'est pas nécessaire pour la méthode en Java.
• Les constructeurs ne renvoient aucun type tandis que les méthodes ont le type de retour ou vide if ne renvoie aucune valeur.
• Les constructeurs ne sont appelés qu'une seule fois au moment de la création de l'objet, tandis que les méthodes peuvent être appelées plusieurs fois.

Voyons maintenant la syntaxe du constructeur invoqué au moment de la création d'un objet ou d'une instance.

class Geek {   .......  // A Constructor  Geek() {  }  ....... } // We can create an object of the above class // using the below statement. This statement // calls above constructor. Geek obj = new Geek();>

La première ligne d'un constructeur est un appel à super() ou this(), (un appel à un constructeur de super-classe ou un constructeur surchargé), si vous ne tapez pas l'appel à super dans votre constructeur, Le compilateur vous fournira un appel sans argument à super sur la première ligne de votre code, le super constructeur doit être appelé pour créer un objet :

Si vous pensez que votre classe n’est pas une sous-classe, alors qu’elle l’est en réalité, chaque classe en Java est la sous-classe d’une classe. objet même si vous ne dites pas extends object dans la définition de votre classe.

Besoin de constructeurs en Java

Pensez à une boîte. Si nous parlons d'une classe de boîte, elle aura des variables de classe (par exemple longueur, largeur et hauteur). Mais lorsqu'il s'agit de créer son objet (c'est-à-dire que la boîte existera désormais dans la mémoire de l'ordinateur), alors une boîte peut-elle être là sans valeur définie pour ses dimensions ? La réponse est N Ô .
Les constructeurs sont donc utilisés pour attribuer des valeurs aux variables de classe au moment de la création de l'objet, soit explicitement par le programmeur, soit par Java lui-même (constructeur par défaut).

point numpy

Quand le constructeur Java est appelé ?

Chaque fois qu'un objet est créé à l'aide d'un nouveau() mot-clé, au moins un constructeur (il peut s'agir du constructeur par défaut) est invoqué pour attribuer des valeurs initiales au membres de données de la même classe. Les règles d'écriture des constructeurs sont les suivantes :

• Le(s) constructeur(s) d'une classe doivent avoir le même nom que le nom de la classe dans laquelle elle réside.
• Un constructeur en Java ne peut pas être abstrait, final, statique ou synchronisé.
• Les modificateurs d'accès peuvent être utilisés dans la déclaration du constructeur pour contrôler son accès, c'est-à-dire quelle autre classe peut appeler le constructeur.

Jusqu’à présent, nous avons appris que les constructeurs sont utilisés pour initialiser l’état de l’objet. Comme méthodes , un constructeur contient également une collection d'instructions (c'est-à-dire des instructions) qui sont exécutées au moment de la création de l'objet.

Types de constructeurs en Java

C’est le bon moment pour discuter des types de constructeur, il existe donc principalement trois types de constructeurs en Java mentionnés ci-dessous :

• Constructeur par défaut
• Constructeur paramétré
• Copier le constructeur

1. Constructeur par défaut en Java

Un constructeur qui n’a aucun paramètre est appelé constructeur par défaut. Un constructeur par défaut est invisible. Et si nous écrivons un constructeur sans argument, le compilateur ne crée pas de constructeur par défaut. Il est retiré. Il est surchargé et appelé constructeur paramétré. Le constructeur par défaut est devenu le constructeur paramétré. Mais le constructeur paramétré ne peut pas modifier le constructeur par défaut. Le constructeur par défaut peut être implicite ou explicite. Si nous ne définissons pas explicitement, nous obtenons un constructeur par défaut implicite. Si nous écrivons manuellement un constructeur, celui implicite est remplacé.

Exemple:

// Java Program to demonstrate // Default Constructor import java.io.*; // Driver class class GFG {  // Default Constructor  GFG() { System.out.println('Default constructor'); }  // Driver function  public static void main(String[] args)  {  GFG hello = new GFG();  } }>

Default constructor>

Note: Le constructeur par défaut fournit les valeurs par défaut à l'objet comme 0, null, etc. selon le type.

2. Constructeur paramétré en Java

Un constructeur qui a des paramètres est appelé constructeur paramétré. Si nous voulons initialiser les champs de la classe avec nos propres valeurs, alors utilisez un constructeur paramétré.

Exemple:

ankita dave

// Java Program for Parameterized Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  Geek(String name, int id)  {  this.name = name;  this.id = id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  } }>

GeekName :Avinash and GeekId :68>

N'oubliez pas : le constructeur renvoie-t-il une valeur ?

Il n'y a aucune instruction de valeur de retour dans le constructeur, mais le constructeur renvoie l'instance de classe actuelle. Nous pouvons écrire « return » dans un constructeur.

Désormais, le sujet le plus important qui entre en jeu est la forte incorporation de OOPS avec les constructeurs, connue sous le nom de surcharge de constructeur. Tout comme les méthodes, nous pouvons surcharger les constructeurs pour créer des objets de différentes manières. Le compilateur différencie les constructeurs en fonction du nombre de paramètres, des types de paramètres et de l'ordre des paramètres.

Exemple:

// Java Program to illustrate constructor overloading // using same task (addition operation ) for different // types of arguments. import java.io.*; class Geek {  // constructor with one argument  Geek(String name)  {  System.out.println('Constructor with one '  + 'argument - String : ' + name);  }  // constructor with two arguments  Geek(String name, int age)  {  System.out.println(  'Constructor with two arguments : '  + ' String and Integer : ' + name + ' ' + age);  }  // Constructor with one argument but with different  // type than previous..  Geek(long id)  {  System.out.println(  'Constructor with one argument : '  + 'Long : ' + id);  } } class GFG {  public static void main(String[] args)  {  // Creating the objects of the class named 'Geek'  // by passing different arguments  // Invoke the constructor with one argument of  // type 'String'.  Geek geek2 = new Geek('Shikhar');  // Invoke the constructor with two arguments  Geek geek3 = new Geek('Dharmesh', 26);  // Invoke the constructor with one argument of  // type 'Long'.  Geek geek4 = new Geek(325614567);  } }>

Constructor with one argument - String : Shikhar Constructor with two arguments : String and Integer : Dharmesh 26 Constructor with one argument : Long : 325614567>

3. Copier le constructeur en Java

Contrairement aux autres constructeurs, le constructeur de copie est transmis avec un autre objet qui copie les données disponibles de l'objet transmis vers l'objet nouvellement créé.

taille alpha bêta

Note: En Java, il n'existe pas de constructeur de copie intégré disponible comme dans d'autres langages de programmation tels que C++, à la place, nous pouvons créer notre propre constructeur de copie en passant l'objet de la même classe à l'autre instance (objet) de la classe.

Exemple:

// Java Program for Copy Constructor import java.io.*; class Geek {  // data members of the class.  String name;  int id;  // Parameterized Constructor  Geek(String name, int id)  {  this.name = name;  this.id = id;  }  // Copy Constructor  Geek(Geek obj2)  {  this.name = obj2.name;  this.id = obj2.id;  } } class GFG {  public static void main(String[] args)  {  // This would invoke the parameterized constructor.  System.out.println('First Object');  Geek geek1 = new Geek('Avinash', 68);  System.out.println('GeekName :' + geek1.name  + ' and GeekId :' + geek1.id);  System.out.println();  // This would invoke the copy constructor.  Geek geek2 = new Geek(geek1);  System.out.println(  'Copy Constructor used Second Object');  System.out.println('GeekName :' + geek2.name  + ' and GeekId :' + geek2.id);  } }>

First Object GeekName :Avinash and GeekId :68 Copy Constructor used Second Object GeekName :Avinash and GeekId :68>

Pour en savoir plus sur les constructeurs, deux concepts sont largement utilisés, comme indiqué ci-dessous :

• Chaînage de constructeur
• Copier le constructeur

FAQ sur les constructeurs Java

1. Qu'est-ce qu'un constructeur en Java ?

Un constructeur en Java est un méthode spéciale utilisé pour initialiser des objets.

2. Un constructeur Java peut-il être privé ?

Oui, un constructeur peut être déclaré privé. Un constructeur privé est utilisé pour restreindre la création d'objets.