Constructeur Java

java constructor class

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Ce tutoriel abordera Java Constructor, ses types et concepts tels que la surcharge de constructeur et le chaînage de constructeurs avec des exemples de code:

De nos tutoriels précédents, nous savons que l'instance d'une classe est appelée un objet. Un objet d'une classe est créé à l'aide du mot-clé «new». Une méthode spéciale appelée «constructeur» est appelée lorsque nous créons un objet avec un nouveau mot-clé ou lorsque l'objet est instancié.

Un constructeur est défini comme un bloc de code pour initialiser l'objet de classe. C'est identique à la méthode mais ce n'est pas une méthode. Cependant, cela peut être qualifié de «méthode spéciale» en Java.

=> Cliquez ici pour voir de A à Z des didacticiels de formation Java ici.

Constructeurs en Java

Ce que vous apprendrez:

Constructeur Java
Conclusion
- lecture recommandée

Le constructeur Java est utilisé pour initialiser l'objet qui vient d'être créé. Un objet doit avoir des données avant d'être utilisé dans le programme. Par conséquent, nous utilisons un constructeur afin de pouvoir attribuer des données initiales à l'objet.

A titre d'exemple simple, considérons une classe ABC pour laquelle nous devons créer un objet. Créons un objet 'myObj' pour la classe ABC à l'aide d'un nouveau mot-clé.

ABC myObj = new ABC ();

L'instruction ci-dessus crée un objet myObj. Lors de la création de cet objet, un constructeur pour la classe ABC sans argument est appelé (ABC () indique qu'il n'y a pas d'arguments pour le constructeur). Comme il n'y a pas d'arguments fournis pour le constructeur ci-dessus, les champs membres de myObj seront initialisés à leurs valeurs initiales par défaut.

Par exemple,

Les types de données numériques comme int sont définis sur 0.
La valeur de la variable de type de données Char est définie sur le caractère nul (« 0»).
Les références sont définies sur null.

Dans ce didacticiel, nous aborderons les constructeurs en détail ainsi que les différents constructeurs utilisés en Java.

Comment créer un constructeur en Java

Pour créer un constructeur en Java, nous devons suivre certaines règles comme indiqué ci-dessous.

Le constructeur de classe porte le même nom que celui de la classe.
Il ne peut pas y avoir de constructeur final, abstrait, synchronisé ou statique. C'est parce que le Final agit comme une constante, abstraite ne peut pas être instanciée. Alors que synchronized est utilisé dans le cas du multi threading, et le mot clé static est utilisé au niveau de la classe.
Nous pouvons utiliser des modificateurs d'accès avec les constructeurs.
Un constructeur ne peut pas avoir de type de retour.

Par exemple,définissons un étudiant de classe comme suit:

class Student{ String name; int roll_no; }

Nous pouvons créer des objets de la classe ci-dessus en utilisant le nouveau mot-clé. Pendant la création de l'objet, nous pouvons initialiser les variables à deux membres de cette classe en fournissant un constructeur. Notez que même si nous ne fournissons pas de constructeur et exécutons simplement l'instruction ci-dessous,

Élève étudiant = nouvel étudiant ();

Néanmoins, Java exécutera un constructeur par défaut qui initialisera les variables à deux membres à leurs valeurs par défaut du système. Maintenant, si nous voulons que la valeur initiale de Student.name soit «Keith» et roll_no soit 27, alors pour ce faire, nous pouvons créer la méthode constructeur suivante.

Student () { name = 'Keith'; roll_no = 27; }

Lorsque nous créons un objet de la classe étudiante avec la déclaration ci-dessous

Student student = new Student ();

Ensuite, les valeurs initiales des variables membres name et roll_no seront respectivement Keith et 27.

Maintenant qu'un constructeur est créé, quand sera-t-il appelé?

Un constructeur est appelé à chaque fois qu'un objet est créé avec le nouveau mot-clé comme dans le cas ci-dessus. Comme déjà mentionné, si aucun constructeur n'est fourni, Java fournit un constructeur par défaut qui est appelé lorsque l'objet est créé à l'aide du mot-clé new.

Exemple de constructeur

Le programme suivant montre un exemple de constructeur dans lequel nous avons un constructeur simple sans aucun argument. Ce constructeur affecte simplement des valeurs initiales à ses variables membres.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Production:

Exemple de sortie de démonstration de classe

Constructeur par défaut en Java

Le constructeur par défaut est également appelé le constructeur vide . Ce constructeur est inséré par le compilateur Java dans le code de classe où il n'y a pas de constructeur implémenté par le programmeur. Le constructeur par défaut est inséré lors de la compilation et n'apparaîtra donc que dans le fichier «.class» et non dans le code source.

Considérez la classe Java suivante.

fichier source (.java) fichier de classe (.class)

Classe Java

Dans la figure ci-dessus, la première figure montre le code source dans lequel nous n'avons spécifié aucun constructeur. Ainsi, lorsque nous compilons ce code et que le fichier .class est généré, nous pouvons voir que le compilateur Java a inséré un constructeur par défaut comme le montre la figure ci-contre (en bleu).

Remarque:

Parfois, un constructeur par défaut est utilisé pour décrire un constructeur sans argument en Java. Mais ces deux termes sont différents en réalité. Le constructeur sans argument est un type de constructeur en Java spécifié par le programmeur. Le constructeur par défaut est le constructeur inséré par le compilateur Java.

Questions et réponses entretien chez hp alm

Par conséquent, bien que ces deux termes soient utilisés de manière interchangeable par la plupart des programmeurs, il est conseillé de ne pas confondre ces deux termes.

Lorsque Java insère un constructeur par défaut, si le programme a des variables, les valeurs par défaut leur sont affectées.

Le tableau ci-dessous montre les valeurs par défaut de chaque type de données.

Taper	Valeur par défaut
carboniser	u0000
Objet	Référence null
booléen	faux
octet	0
court	0
int	0
longue	0L
flotter	0,0f
double	0,0 j

Le programme suivant donne un exemple de constructeur par défaut en Java.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Production:

constructeur par défaut - sortie

Types de constructeurs en Java

Il existe deux types de constructeurs en Java, comme indiqué ci-dessous.

Types de constructeurs en Java

# 1) Constructeur sans argument

Un constructeur sans aucun argument est appelé constructeur sans argument ou sans argument. Si nous n'avons pas de constructeur sans argument, le compilateur Java ne crée pas de constructeur par défaut pour la classe.

En général, si nous définissons un constructeur dans notre classe, alors le constructeur par défaut n'est pas inséré par le compilateur Java.

Ci-dessous, un exemple du constructeur sans arg

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Production:

Constructeur sans argument

Dans ce programme, nous avons fourni un constructeur sans argument. Ici, nous imprimons quelques messages incluant les variables membres. Nous pouvons voir dans la sortie que les messages du constructeur sont affichés indiquant que le constructeur no-args est exécuté.

# 2) Constructeur paramétré

Un constructeur paramétré a un ou plusieurs paramètres. Nous pouvons utiliser un constructeur paramétré au cas où nous aurions besoin de passer des valeurs initiales à la variable membre de la classe.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Production:

Constructeur paramétré en Java

Ici, nous avons fourni un constructeur paramétré qui prend deux arguments, à savoir name et id.

Dans le corps du constructeur, les arguments sont affectés en tant que valeurs respectivement au nom et à l'id des variables membres.

Ensuite, dans la méthode principale, lorsque nous créons un nouvel objet à l'aide du mot-clé new, nous passons deux valeurs au nom de la classe à la suite d'un nouveau mot-clé. Cela indique que nous appelons le constructeur paramétré. Lorsque nous affichons les variables membres, nous pouvons voir qu'elles ont les valeurs que nous avons passées lors de la création de l'objet.

Constructeurs surchargés en Java

Maintenant, la question se pose de savoir si une classe peut avoir plus d'un constructeur ou est-ce qu'une classe ne peut avoir qu'un seul constructeur?

Eh bien, nous pouvons avoir plusieurs constructeurs dans une classe. Une classe peut contenir autant de constructeurs tant qu'ils sont correctement surchargés.

Alors, que signifie exactement la surcharge des constructeurs?

La surcharge de constructeur est un mécanisme qui permet à une classe d'avoir autant de constructeurs afin que tous ces constructeurs aient des listes de paramètres différentes, que ce soit en fonction des types de paramètres ou de l'ordre des paramètres.

Le programme ci-dessous illustre la surcharge du constructeur.

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Production:

Surchargé - sortie

Dans le programme ci-dessus, nous avons une classe contenant trois constructeurs. Le premier constructeur est un constructeur sans argument, puis nous en avons un chacun avec un argument et deux arguments respectivement. Comme le constructeur a une liste de paramètres unique, on peut dire que les constructeurs sont surchargés.

Constructeur ‘this ()’ en Java

Dans une classe contenant plusieurs constructeurs, que se passe-t-il si nous voulons appeler un constructeur à partir d'un autre constructeur de cette classe?

Pour cela, nous utilisons le mot-clé «this» à l'intérieur du constructeur à partir duquel nous voulons appeler un autre constructeur.

Ainsi, lorsqu'une classe a plusieurs constructeurs, un constructeur sans argument et un constructeur paramétré, nous utilisons le mot-clé «this» pour appeler un constructeur paramétré à partir du constructeur no-args. Ceci est également appelé «Invocation explicite du constructeur».

Pourquoi avons-nous besoin de ce mot-clé?

Nous en avons besoin car l'invocation explicite des constructeurs n'est pas possible directement en utilisant uniquement le nom du constructeur.

Points à noter:

Le mot-clé «this» doit être la première instruction du constructeur appelant.
Si un constructeur a le mot-clé «this», alors il ne peut pas avoir «super». Cela signifie que le constructeur peut avoir soit super soit this.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Production:

Constructeur ‘this ()’ en Java

Dans le programme ci-dessus, nous avons une «TestClass» avec deux constructeurs. Nous appelons cela («SoftwareTestingHelp») à partir du constructeur no-args. Il s'agit de l'appel explicite du constructeur paramétré.

Copier le constructeur en Java

Nous connaissons le constructeur de copie en C ++. Le constructeur de copie est un constructeur qui a une référence d'objet comme argument et un nouvel objet est créé à l'aide des données de l'objet de référence.

C ++ fournit un constructeur de copie par défaut s'il n'en existe pas dans le programme.

Java prend également en charge le constructeur de copie, mais il ne fournit pas de constructeur de copie par défaut.

Le programme Java suivant illustre le constructeur de copie à l'aide de l'exemple classique de nombres complexes qui ont des composants réels et imaginaires.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Production:

comment instancier une file d'attente en java

Copier le constructeur dans Java 7

Le programme ci-dessus a une classe «Complex» qui a un constructeur paramétré et un constructeur de copie. Dans la méthode principale, nous créons d'abord un objet c1 à l'aide d'un constructeur paramétré. Puis en utilisant l'instruction ci-dessous,

Complex c2 = new Complex (c1);

L'instruction ci-dessus appelle le constructeur de copie lorsque la référence c1 est transmise au constructeur lors de la création d'un nouvel objet c2.

Constructor Chaining en Java

Le chaînage de constructeurs est un processus par lequel un constructeur appelle un autre constructeur de la même classe.

Même lorsque nous avons hérité d'une classe de base, le constructeur de la classe de base est appelé en premier lorsque l'objet de classe enfant est créé. Ceci est également un exemple de chaînage de constructeur.

En Java, le chaînage des constructeurs peut être réalisé en utilisant deux approches:

Dans la même classe : Lorsque nous appelons un constructeur depuis un autre constructeur de la même classe, nous pouvons utiliser ce mot-clé ().
De la classe de base: Un constructeur de la classe de base peut être appelé par celui de la classe dérivée à l'aide du mot clé super.

Pourquoi avons-nous besoin d'un chaînage constructeur?

Lorsque nous voulons effectuer plusieurs tâches dans notre constructeur, au lieu d'exécuter chaque tâche dans un constructeur, nous décomposons les tâches en plusieurs constructeurs, puis nous appelons les constructeurs les uns des autres, ce qui entraîne un chaînage des constructeurs.

Vous trouverez ci-dessous certaines des règles que nous devons suivre lors de l'exécution du chaînage du constructeur.

Le chaînage du constructeur est effectué dans n'importe quel ordre et produira les mêmes résultats.
Le mot clé 'this' doit être la première expression du constructeur.
Nous devrions avoir au moins un constructeur sans ce mot clé.

Lorsque nous avons un héritage dans notre programme, nous pouvons également effectuer un chaînage de constructeur. Dans ce cas, la sous-classe appellera le constructeur de la classe de base. En faisant cette création d’objets de sous-classe commence par l’initialisation des membres de la superclasse.

Nous allons maintenant implémenter le chaînage du constructeur en Java en utilisant les approches ci-dessus.

# 1) Constructeur chaînant dans la même classe

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Production:

chaînage au sein d

Comme déjà mentionné, nous réalisons un chaînage de constructeurs dans la même classe en utilisant le mot-clé «this». Dans le programme ci-dessus, nous avons trois constructeurs et nous appelons un constructeur à partir d'un autre en utilisant le mot-clé «this».

De la classe de base

Lorsqu'une classe hérite d'une autre classe, le constructeur de la classe parent est appelé en premier lorsque nous créons un objet d'une classe dérivée qui est le chaînage du constructeur.

Si nous voulons appeler explicitement le constructeur de classe de base dans la classe dérivée, nous devons utiliser le mot-clé «super» à cette fin. En utilisant le mot-clé 'super', nous pouvons appeler les constructeurs de superclasse dans la hiérarchie d'héritage jusqu'à ce que nous atteignions la classe la plus élevée.

Le programme ci-dessous montre l’utilisation d’un mot clé «super» pour le chaînage des constructeurs.

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Production:

De la classe de base

Dans le programme ci-dessus, nous invoquons le constructeur paramétré de la classe dérivée avec la valeur «Java». Ce constructeur a à son tour un appel au constructeur de classe de base en utilisant «super (nom);» qui exécute le constructeur paramétré de la classe de base.

Questions fréquemment posées

Q # 1) Comment créez-vous un constructeur en Java?

Répondre: Nous créons un constructeur comme une méthode spéciale qui porte le même nom que le nom de la classe. Un constructeur ne peut pas non plus avoir de type de retour. Il peut avoir des modificateurs d'accès, mais il ne peut pas être final, statique, abstrait ou synchronisé.

Si ABC est une classe, alors nous pouvons définir son constructeur comme

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

Q # 2) Quel est l'avantage d'un constructeur en Java?

Répondre: En utilisant le constructeur, nous pouvons initialiser les membres de la classe comme première chose à laquelle l'objet moment est créé. Le constructeur élimine le besoin d'appeler implicitement des méthodes normales.

Nous pouvons effectuer diverses tâches liées à l'initialisation, aux tâches de démarrage, etc. dans le constructeur car les constructeurs sont appelés lors de la phase de création d'objet.

Q # 3) Pourquoi les constructeurs sont-ils utilisés?

Répondre: Les constructeurs sont principalement utilisés pour initialiser les membres de la classe et sont appelés lors de la création de l'objet de la classe.

Q # 4) Le constructeur peut-il être privé?

Répondre: Oui, nous pouvons avoir un constructeur privé. Lorsque le constructeur est privé, la classe peut être empêchée d'être instanciée.

Q # 5) Le constructeur peut-il être définitif?

Répondre: Non, nous ne pouvons pas avoir de constructeur final.

Conclusion

Dans ce tutoriel, nous avons commencé notre discussion sur les constructeurs en Java. Nous avons appris les bases du constructeur, sa création et les règles à suivre. Nous avons également discuté des constructeurs de copie en Java.

Le constructeur par défaut et les types de constructeurs et les concepts tels que la surcharge de constructeur et le chaînage de constructeurs ont été présentés avec des exemples. Dans le cadre de ces sujets, nous avons également vu l’utilisation du mot-clé «this» dans les constructeurs.

=> Lisez la série de formations Easy Java.

Constructeur Java - Constructeurs de classe, de copie et par défaut