Maîtriser les constructeurs Java : Types, utilisation et exemples pratiques

Constructeurs Java

Dans ce tutoriel, nous allons apprendre les constructeurs Java, leurs types et comment les utiliser avec des exemples.

Qu'est-ce qu'un constructeur ?

Un constructeur en Java est similaire à une méthode qui est invoquée quand un objet de la classe est créé.

Contrairement aux méthodes Java, un constructeur a le même nom que la classe et n'a aucun type de retour. 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.

Lecture recommandée : Pourquoi les constructeurs ne retournent pas de valeurs

---

Exemple 1 : Constructeur Java

class Main {
    private String name;
    // constructeur
    Main() {
        System.out.println("Constructeur appelé :");
        name = "Programiz";
    }
    public static void main(String[] args) {
        // le constructeur est invoqué lors
        // de la création d'un objet de la classe Main
        Main obj = new Main();
        System.out.println("The name is " + obj.name);
    }
}

Sortie :

Constructeur appelé :
The name is Programiz

Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Main(). À l'intérieur du constructeur, nous initialisons la valeur de la variable name.

Remarquez l'instruction de création d'un objet de la classe Main.

Main obj = new Main();

Ici, quand l'objet est créé, le constructeur Main() est appelé. Et la valeur de la variable name est initialisée.

Donc, le programme affiche la valeur de la variable name comme Programiz.

---

Types de constructeurs

En Java, les constructeurs peuvent être divisés en 3 types :

1. Constructeur sans argument
2. Constructeur paramétré
3. Constructeur par défaut

---

1. Constructeurs Java sans argument

Similaire aux méthodes, un constructeur Java peut ou non avoir des paramètres (arguments).

Si un constructeur n'accepte aucun paramètre, il est connu comme constructeur sans argument. Par exemple,

private Constructor() {
    // corps du constructeur
}

---

Exemple 2 : Constructeur privé sans argument en Java

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

Sortie :

Constructeur appelé
Valeur de i : 5

Dans l'exemple ci-dessus, nous avons créé un constructeur Main(). Ici, le constructeur n'accepte aucun paramètre. Donc, c'est un constructeur sans argument.

Remarquez que nous avons déclaré le constructeur comme private.

Une fois un constructeur déclaré private, il ne peut pas être accessible depuis l'extérieur de la classe. Donc, la création d'objets depuis l'extérieur de la classe est interdite en utilisant le constructeur privé.

Ici, nous créons l'objet à l'intérieur de la même classe. Donc, le programme peut accéder au constructeur. Pour en savoir plus, visitez Implémentation d'un constructeur privé en Java.

Cependant, si nous voulons créer des objets en dehors de la classe, nous devons déclarer le constructeur comme public.

Exemple 3 : Constructeurs publics sans argument en Java

class Company {
    String name;
    // constructeur public
    public Company() {
        name = "Programiz";
    }
}
class Main {
    public static void main(String[] args) {
        // objet créé dans une autre classe
        Company obj = new Company();
        System.out.println("Company name = " + obj.name);
    }
}

Sortie :

Company name = Programiz

Lecture recommandée : Modificateur d'accès Java

---

2. Constructeur paramétré Java

Un constructeur Java peut aussi accepter un ou plusieurs paramètres. De tels constructeurs sont connus comme constructeurs paramétrés (constructeur avec paramètres).

Exemple 4 : Constructeur paramétré

class Main {
    String languages;
    // constructeur acceptant une seule valeur
    Main(String lang) {
        languages = lang;
        System.out.println(languages + " Programming Language");
    }
    public static void main(String[] args) {
        // appel du constructeur en passant une seule valeur
        Main obj1 = new Main("Java");
        Main obj2 = new Main("Python");
        Main obj3 = new Main("C");
    }
}

Sortie :

Java Programming Language
Python Programming Language
C Programming Language

Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Main(). Ici, le constructeur prend un seul paramètre. Remarquez l'expression,

Main obj1 = new Main("Java");

Ici, nous passons une seule valeur au constructeur. Basé sur l'argument passé, la variable language est initialisée à l'intérieur du constructeur.

---

3. Constructeur par défaut Java

Si nous ne créons aucun constructeur, le compilateur Java crée automatiquement un constructeur sans argument pendant l'exécution du programme. Ce constructeur est appelé constructeur par défaut.

Exemple 5 : Constructeur par défaut

class Main {
    int a;
    boolean b;
    public static void main(String[] args) {
        // Un constructeur par défaut est appelé
        Main obj = new Main();
        System.out.println("Valeur par défaut :");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

Sortie :

a = 0
b = false

Ici, nous n'avons créé aucun constructeur. Donc, le compilateur Java crée automatiquement le constructeur par défaut.

Le constructeur par défaut initialise toutes les variables d'instance non initialisées avec des valeurs par défaut.

Type	Valeur par défaut
boolean	false
byte	0
short	0
int	0
long	0L
char	\u0000
float	0.0f
double	0.0d
object	Référence null

Dans le programme ci-dessus, les variables a et b sont initialisées avec la valeur par défaut 0 et false respectivement.

Le programme ci-dessus est équivalent à :

class Main {
    int a;
    boolean b;
    // un constructeur privé
    private Main() {
        a = 0;
        b = false;
    }
    public static void main(String[] args) {
        // appel du constructeur
        Main obj = new Main();
        System.out.println("Valeur par défaut :");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

La sortie du programme est la même que l'Exemple 5.

---

Notes importantes sur les constructeurs Java

• Les constructeurs sont invoqués implicitement quand vous instanciez des objets.
• Les deux règles pour créer un constructeur sont :
  Le nom du constructeur doit être le même que la classe.
  Un constructeur Java ne doit pas avoir de type de retour.
• Si une classe n'a pas de constructeur, le compilateur Java crée automatiquement un constructeur par défaut pendant l'exécution. Le constructeur par défaut initialise les variables d'instance avec des valeurs par défaut. Par exemple, la variable int sera initialisée à 0.
• Types de constructeurs :
  Constructeur sans argument - constructeur qui n'accepte aucun argument
  Constructeur paramétré - constructeur qui accepte des arguments
  Constructeur par défaut - constructeur créé automatiquement par le compilateur Java s'il n'est pas explicitement défini.
• Un constructeur ne peut pas être abstract, static ou final.
• Un constructeur peut être surchargé mais ne peut pas être redéfini.

---

Surcharge de constructeurs en Java

Similaire à la surcharge de méthodes Java, nous pouvons aussi créer deux ou plusieurs constructeurs avec des paramètres différents. Cela s'appelle la surcharge de constructeurs.

Exemple 6 : Surcharge de constructeurs Java

class Main {
    String language;
    // constructeur sans paramètre
    Main() {
        this.language = "Java";
    }
    // constructeur avec un paramètre unique
    Main(String language) {
        this.language = language;
    }
    public void getName() {
        System.out.println("Programming Language: " + this.language);
    }
    public static void main(String[] args) {
        // appel constructeur sans paramètre
        Main obj1 = new Main();
        // appel constructeur avec un paramètre unique
        Main obj2 = new Main("Python");
        obj1.getName();
        obj2.getName();
    }
}

Sortie :

Programming Language: Java
Programming Language: Python

Dans l'exemple ci-dessus, nous avons deux constructeurs : Main() et Main(String language). Ici, les deux constructeurs initialisent la valeur de la variable language avec des valeurs différentes.

Basé sur le paramètre passé lors de la création de l'objet, différents constructeurs sont appelés et différentes valeurs sont assignées.

Il est aussi possible d'appeler un constructeur depuis un autre constructeur. Pour en savoir plus, visitez Appel d'un constructeur depuis un autre en Java.

Note : Nous avons utilisé le mot-clé this pour spécifier la variable de la classe. Pour en savoir plus sur le mot-clé this, visitez Mot-clé this en Java.