Instanciation d'objets: Constructeurs

1. Le rôle du constructeur

Reprenons l'exemple de la classe Voiture de la leçon précédente. Pour créer une voiture, nous faisions ceci :

Voiture maVoiture = new Voiture(); // 1. Création de l'objet
maVoiture.marque = "Toyota";      // 2. Initialisation de l'attribut marque
maVoiture.modele = "Corolla";     // 3. Initialisation de l'attribut modele
maVoiture.annee = 2020;           // 4. Initialisation de l'attribut annee

Cette méthode présente deux inconvénients majeurs :

1. Verbosité : Il faut plusieurs lignes de code pour initialiser un seul objet.
2. État incohérent : Entre la ligne 1 et la ligne 4, l'objet maVoiture existe, mais il est dans un état incomplet (ses attributs sont null ou 0). On pourrait oublier d'initialiser un attribut important.

La solution à ce problème est le constructeur. C'est une méthode spéciale qui est appelée automatiquement au moment de la création de l'objet (lors de l'appel à new) et dont le rôle est d'initialiser ses attributs.

Les règles d'un constructeur sont simples :

• Il porte exactement le même nom que la classe.
• Il n'a aucun type de retour, pas même void.

La vidéo suivante introduit parfaitement ce concept.

2. Constructeur par Défaut et Constructeur Paramétré

Il existe deux types principaux de constructeurs que vous devez connaître.

Le constructeur par défaut

Si vous ne définissez AUCUN constructeur dans votre classe, Java en fournit un pour vous, gratuitement et de manière invisible. C'est le constructeur par défaut.

• Il ne prend aucun paramètre.
• Son corps est vide.
• Il initialise les attributs à leurs valeurs par défaut (0 pour les nombres, false pour les booléens, null pour les objets).

C'est ce constructeur que nous avons utilisé sans le savoir jusqu'à présent (new Voiture()).

Attention, point crucial : Dès que vous définissez au moins un constructeur personnalisé (même un seul), Java ne fournit plus le constructeur par défaut automatiquement. Si vous en avez toujours besoin, vous devrez le déclarer explicitement.

Le constructeur paramétré

C'est là que la magie opère. Un constructeur paramétré accepte des arguments, ce qui nous permet de créer et d'initialiser un objet en une seule ligne de code.

public class Voiture {
    String marque;
    String modele;
    int annee;

    // Un constructeur paramétré
    public Voiture(String marqueVoiture, String modeleVoiture, int anneeVoiture) {
        // Initialisation des attributs avec les valeurs passées en paramètres
        marque = marqueVoiture;
        modele = modeleVoiture;
        annee = anneeVoiture;
    }
}

// Utilisation dans la méthode main
public class Garage {
    public static void main(String[] args) {
        // Création et initialisation en une seule étape !
        Voiture maVoiture = new Voiture("Toyota", "Corolla", 2020);
        
        System.out.println("Marque : " + maVoiture.marque); // Affiche "Toyota"
    }
}

Pour une explication plus détaillée de ces deux types de constructeurs, je vous invite à lire la ressource suivante.

3. La surcharge de constructeurs (Overloading)

Comme votre expérience en Python ou PHP vous a sûrement familiarisé avec les paramètres optionnels, vous vous demandez peut-être comment obtenir une flexibilité similaire en Java. La réponse est la surcharge de constructeurs (constructor overloading).

Cela signifie simplement que vous pouvez définir plusieurs constructeurs dans la même classe, à condition que leur signature (le nombre et/ou le type de leurs paramètres) soit différente. Java choisira alors le constructeur approprié en fonction des arguments que vous fournissez lors de l'appel à new.

public class Produit {
    String nom;
    double prix;

    // 1. Constructeur par défaut (explicite)
    public Produit() {
        this.nom = "Produit inconnu";
        this.prix = 0.0;
    }

    // 2. Constructeur avec seulement le nom
    public Produit(String nom) {
        this.nom = nom;
        this.prix = 9.99; // Un prix par défaut
    }

    // 3. Constructeur avec nom et prix
    public Produit(String nom, double prix) {
        this.nom = nom;
        this.prix = prix;
    }
}

// Utilisation
Produit p1 = new Produit(); // Appelle le constructeur 1
Produit p2 = new Produit("Livre Java"); // Appelle le constructeur 2
Produit p3 = new Produit("Clavier mécanique", 120.50); // Appelle le constructeur 3

La vidéo ci-dessous illustre ce concept de manière très efficace avec un exemple de classe Player.

4. Bonnes pratiques : this et chaînage de constructeurs

Deux pratiques professionnelles sont à adopter lorsque vous travaillez avec des constructeurs.

Utilisation systématique de this

Il est courant de donner aux paramètres du constructeur le même nom que les attributs de la classe pour plus de clarté. Dans ce cas, le mot-clé this devient obligatoire pour désambiguïser.

• this.nom fait référence à l'attribut de l'objet.
• nom (sans this) fait référence au paramètre de la méthode/constructeur.

public class Personne {
    String nom;
    int age;

    public Personne(String nom, int age) {
        this.nom = nom; // Assigne le paramètre 'nom' à l'attribut 'this.nom'
        this.age = age; // Assigne le paramètre 'age' à l'attribut 'this.age'
    }
}

Chaînage de constructeurs avec this()

Pour éviter la duplication de code entre vos constructeurs surchargés, vous pouvez faire en sorte qu'un constructeur en appelle un autre en utilisant this(...). Cela centralise la logique d'initialisation.

L'appel à this(...) doit obligatoirement être la première instruction d'un constructeur.

public class Produit {
    String nom;
    double prix;

    // Constructeur principal qui fait tout le travail
    public Produit(String nom, double prix) {
        this.nom = nom;
        this.prix = prix;
    }

    // Constructeur qui appelle le constructeur principal avec un prix par défaut
    public Produit(String nom) {
        this(nom, 9.99); // Appel à l'autre constructeur
    }
}

L'article de Rachid Saad explique également très bien ce concept de chaînage dans la section "6.2. Utiliser this dans les constructeurs et les méthodes".

5. Exercice pratique : La classe Client

Mettons maintenant tout cela en pratique. Vous allez créer une classe Client pour un système e-commerce.

1. Créez une classe Client avec les attributs suivants :

   • long id
   • String nom
   • String prenom
   • String email

2. Ajoutez deux constructeurs :

   • Un constructeur principal qui accepte les 4 attributs (id, nom, prenom, email) et les initialise. Utilisez le mot-clé this.
   • Un second constructeur qui n'accepte que nom, prenom et email. Ce constructeur devra appeler le premier en générant un id aléatoire (par exemple, en utilisant System.currentTimeMillis()). Utilisez le chaînage avec this().

3. Redéfinissez la méthode toString() (comme vu dans le module sur les collections) pour qu'elle retourne une chaîne de caractères décrivant le client, par exemple : Client [id=123, nom=Dupont, prenom=Jean, email=jean.dupont@email.com]. C'est une excellente habitude à prendre pour déboguer facilement.

4. Créez une classe Main avec une méthode main pour tester votre classe Client :

   • Créez une instance de Client en utilisant le constructeur à 4 paramètres.
   • Créez une autre instance en utilisant le constructeur à 3 paramètres.
   • Affichez les deux objets en utilisant System.out.println(). Grâce à toString(), l'affichage devrait être clair et lisible.

N'hésitez pas à expérimenter en ajoutant d'autres constructeurs surchargés !

Conclusion

Aujourd'hui, vous avez fait un grand pas en avant dans la maîtrise de la POO en Java. L'utilisation correcte des constructeurs est le signe d'un code plus mature et plus sécurisé.

Points clés à retenir :

• Les constructeurs sont des méthodes spéciales qui initialisent un objet lors de sa création avec new.
• Le constructeur par défaut est sans paramètre et est fourni par Java uniquement si aucun autre constructeur n'est défini.
• Les constructeurs paramétrés permettent de créer des objets dans un état valide et complet en une seule ligne.
• La surcharge de constructeurs offre plusieurs manières de créer un objet, apportant de la flexibilité.
• Le chaînage avec this(...) est une bonne pratique pour éviter la duplication de code entre constructeurs.

Dans la prochaine leçon, nous allons renforcer la robustesse de nos classes en abordant l'encapsulation. Nous verrons comment protéger nos attributs du monde extérieur en les rendant private et en ne fournissant qu'un accès contrôlé via des méthodes publiques (les fameux "getters" et "setters").