Constructeurs Java

Dans ce tutoriel, vous découvrirez les constructeurs Java à l'aide d'exemples, comment les créer et les utiliser, ainsi que les différents types de constructeurs.

Qu'est-ce qu'un constructeur ?

En Java, chaque classe a son constructeur, qui est appelé automatiquement lorsque l'objet de la classe est créé. Un constructeur est similaire à une méthode, mais ce n'est pas une méthode.

unJava methodset les constructeurs Java sont distingués par leur nom et leur type de retour. Un constructeur a le même nom que le constructeur de la classe et ne retourne aucune valeur. Par exemple,

class Test {
　　　　Test() {
　　　　　　　　//Corps du constructeur
　　　　}
}

Ici, Test() est un constructeur. Il a le même nom que la classe et n'a pas de type de retour.

class Test {
　　　　void Test() {
　　　　　　　　//　Corps de la méthode
　　　　}
}

　Ici, Test() a le même nom que le nom de la classe, mais il a un type de retour void. Par conséquent, c'est une méthode et non un constructeur.

Exemple : Constructeurs Java

class Main {
　　　private int x;
　　　//　Corps du constructeur
　　　private Main(){
　　　　　　　System.out.println("Le constructeur est appelé");
　　　　　　　x =　5;
　　　}
　　　public static void main(String[] args){
　　　　　　　//Appel du constructeur lors de la création de l'objet
　　　　　　　Main obj = new Main();
　　　　　　　System.out.println("La valeur de x = ")　+　obj.x);
　　　}
}

Sortie:

Le constructeur est appelé
La valeur de x =　5

　Dans l'exemple ci-dessus, nous avons un constructeur privé nommé Main(). Dans la méthode main, nous créons un objet de classe nommé obj.

Main obj = new Main();

　Dans ce processus, le constructeur sera appelé. Par conséquent, exécutez l'instruction print et initialisez la variable x.

Types de constructeurs

En Java, les constructeurs peuvent être divisés en3Type :

• Parameterless constructor

• Default constructor

• Constructeur avec paramètres

Parameterless constructor

Les constructeurs Java peuvent avoir ou ne pas avoir de paramètres. Si un constructeur ne prend pas de paramètres, il est appelé constructeur sans paramètres. Par exemple,

private Constructor() {
　　　//　Corps du constructeur
}

Exemple de constructeur sans paramètres

class Main {
　　　int i;
　　　//Constructeur sans paramètre
　　　private Main(){
　　　　　　　i =　5;
　　　　　　　System.out.println("Objet créé et i = ")　+　i);
　　　}
　　　public　static　void　main(String[]　args)　{
　　　　　　　//Appel du constructeur sans paramètres
　　　　　　　Main obj = new Main();
　　　}
}

Sortie:

Objet créé et i =　5

Ici, la fonction Main() ne prend aucun paramètre.

Avez-vous remarqué que l'accessibilité du constructeur Main() est définie comme privé (private) ?

C'est parce que l'objet est instancié à partir de la même classe. Par conséquent, il peut accéder au constructeur.

Mais, si l'objet est créé en dehors de la classe, il est nécessaire de déclarer le constructeur comme public pour y accéder. Par exemple :

class　Company　{
　　　　String　domainName;
　　　　//　Constructeur public
　　　　public　Company(){
　　　　　　　　domainName = "oldtoolbag.com";
　　　　}
}
public class Main {
　　　　
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Création d'un objet dans une autre classe
　　　　　　　　Company companyObj = new Company();
　　　　　　　　System.out.println("Domain name = ")+　companyObj.domainName);
　　　　}
}

Sortie:

Domain name = oldtoolbag.com

Lecture recommandée : Java access modifiers

Default constructor

Si vous ne créez pas de constructeur, le compilateur Java crée automatiquement un constructeur sans paramètres au moment de l'exécution. Ce constructeur s'appelle le constructeur par défaut. Le constructeur par défaut initialise tous les variables d'instance non initialisées avec des valeurs par défaut.

Exemple : constructeur par défaut

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Appel du constructeur par défaut
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ")　+　obj.a);
　　　　　　　　System.out.println("b = ")　+　obj.b);
　　　　}
}

Sortie:

a = 0
b = false

Dans le programme ci-dessus, nous n'avons pas encore initialisé les valeurs des variables a et b. Mais, lorsque nous créons un objet de la classe, nous pouvons voir dans la sortie que ces valeurs ont été initialisées avec certaines valeurs.

　C'est parce que le compilateur Java crée automatiquement un constructeur par défaut. Ce constructeur utilisera les valeurs par défaut 0 et false pour initialiser les valeurs des variables a et b.

Le programme ci-dessus équivaut à :

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　//Constructeur privé　
　　　　private DefaultConstructor() {
　　　　　　　　a = 0;
　　　　　　　　b = false;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Appel du constructeur
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ")　+　obj.a);
　　　　　　　　System.out.println("b = ")　+　obj.b);
　　　　}
}

Sortie:

a = 0
b = false

Parameterized constructors

De même que pour les méthodes, nous pouvons passer des paramètres au constructeur. Ce type de constructeur s'appelle le constructeur paramétré. Par exemple,

private Constructor (arg1arg2..., argn) {
　　　　//　Corps du constructeur
}

Exemple : constructeur paramétré

class　Vehicle　{
　　　　int　wheels;
　　　　//Constructeur acceptant une seule valeur
　　　　private　Vehicle(int　wheels){
　　　　　　　　this.wheels　=　wheels;
　　　　　　　　System.out.println(wheels　+　"vehicle　wheeler　créé.");
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Appel du constructeur en passant une seule valeur
　　　　　　　　Vehicle　v1　=　new　Vehicle(2);
　　　　　　　　Vehicle　v2　=　new　Vehicle(3);
　　　　　　　　Vehicle　v3　=　new　Vehicle(4);
　　　　}
}

Sortie:

2　vehicle　wheeler　créé.
3　vehicle　wheeler　créé.
4　vehicle　wheeler　créé.

Dans l'exemple précédent, nous avons un constructeur nommé Vehicle(). Le constructeur accepte un paramètre nommé wheels.

Ici, lors de la création d'un objet, nous passons des paramètres au constructeur. Et, basé sur les paramètres, il génère la sortie.

Le surcharge de constructeur en Java

　Comme pour le surcharge de méthode, nous pouvons également surcharger les constructeurs en Java. Si vous ne connaissez pas le surcharge de méthode, veuillez consulterJava method overloading.

Dans le surcharge de constructeur, il y a deux ou plusieurs constructeurs avec des paramètres différents. Par exemple,

class　Company　{
　　　　String　domainName;
　　　　//Constructeur sans paramètre
　　　　public　Company(){
　　　　　　　　this.domainName　=　"default";
　　　　}
　　　　//Constructeur avec un seul paramètre
　　　　public　Company(String　domainName){
　　　　　　　　this.domainName　=　domainName;
　　　　}
　　　　public　void　getName(){
　　　　　　　　System.out.println(this.domainName);
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Appel du constructeur sans paramètre
　　　　　　　　Company　defaultObj　=　new　Company();
　　　　　　　　//Appel du constructeur avec un seul paramètre
　　　　　　　　Company　w3codeboxObj　=　new　Company("oldtoolbag.com");
　　　　　　　　defaultObj.getName();
　　　　　　　　w3codeboxObj.getName();
　　　　}
}

Sortie:

default
oldtoolbag.com

Dans l'exemple précédent, nous avons deux constructeurs : public Company() et public Company(String domainName).

Ici, les deux constructeurs initialisent les variables domainName avec des valeurs différentes.Therefore, depending on the values we need, we can call the constructor from the main() method.

Note that we use the this keyword to specify class variables. For more information about the this keyword, please visitJava this keyword.

Important note

• 　Constructors are implicitly called when objects are instantiated.
  

• The two rules for creating constructors are:

• The name of the constructor should be the same as the name of the class.

• Java constructors must not have a return type.

• If a class does not have a constructor, the Java compiler will automatically create one at runtimeDefault constructorThe default constructor initializes instance variables with default values. For example, an int variable will be initialized to 0

• Constructor types:

• Parameterless constructor　 - Constructors that do not accept any parameters

• Default constructor　 - If no constructor is explicitly defined, the Java compiler will automatically create one.

• Parameterized constructors　 - Constructors that accept parameters

• Constructors cannot be abstract, static, or final.
  

• Constructor overloading is possible but cannot be overridden.