Chaînage de constructeurs

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 23 sur 87.

Le chaînage de constructeurs est le processus d'appel d'un constructeur à partir d'un autre. Cette technique permet d'éviter la duplication de code lorsqu'une classe possède plusieurs constructeurs ou lors de l'utilisation de hiérarchies d'héritage.

Au sein de la même classe, vous pouvez enchaîner les constructeurs en utilisant this(). Cela vous permet d'avoir un constructeur « principal » qui effectue tout le travail, tandis que les autres constructeurs lui délèguent simplement la tâche :

public class Rectangle {
    private int width;
    private int height;
    
    public Rectangle() {
        this(1, 1);  // Appelle le constructeur à deux paramètres
    }
    
    public Rectangle(int size) {
        this(size, size);  // Crée un carré
    }
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

Dans l'héritage, le chaînage des constructeurs se produit automatiquement. Lorsque vous créez un objet d'une sous-classe, Java appelle d'abord le constructeur parent en utilisant super(). Si vous n'appelez pas explicitement super(), Java insère automatiquement super() (la version sans argument) :

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor");
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Doit être la première ligne
        this.breed = breed;
        System.out.println("Dog constructor");
    }
}

La création de new Dog("Buddy", "Labrador") affiche d’abord "Animal constructor", puis "Dog constructor". Cela garantit que les classes parentes sont toujours correctement initialisées avant que la classe enfant n’ajoute sa propre configuration.

Défi

Facile

Construisons un système de commande de produits qui illustre l’enchaînement des constructeurs à la fois au sein d’une classe et dans une hiérarchie d’héritage. Tu verras comment this() enchaîne les constructeurs de la même classe, tandis que super() enchaîne les constructeurs parents.

Tu vas créer trois fichiers pour organiser ton code :

Product.java : crée une classe parente représentant n’importe quel produit dans un magasin. Elle doit avoir :
- Des champs privés pour name (String) et price (double)
- Un constructeur principal qui prend le nom et le prix, initialise les champs et affiche : Product constructor: [name]
- Un deuxième constructeur qui prend uniquement le nom et s’enchaîne avec le constructeur principal à l’aide de this(name, 0.0) afin de définir un prix par défaut de 0.0
- Les méthodes getName() et getPrice() pour accéder aux champs
Electronics.java : crée une sous-classe qui étend Product et ajoute des informations sur la garantie :
- Un champ privé pour warrantyYears (int)
- Un constructeur principal qui prend le nom, le prix et warrantyYears : utilise super(name, price) pour initialiser la classe parente, puis définit la garantie et affiche : Electronics constructor: [warrantyYears] year warranty
- Un deuxième constructeur qui prend uniquement le nom et le prix et s’enchaîne avec le constructeur principal à l’aide de this(name, price, 1) afin de fournir une garantie par défaut d’un an
- Un troisième constructeur qui prend uniquement le nom et s’enchaîne avec le deuxième constructeur à l’aide de this(name, 0.0)
- Une méthode getDetails() qui renvoie : [name] - $[price] ([warrantyYears] year warranty)
Main.java : illustre l’enchaînement des constructeurs en action. Tu recevras trois entrées : un nom de produit (String), un prix (double) et le nombre d’années de garantie (int). Crée un objet Electronics en utilisant les trois paramètres, puis affiche le résultat de getDetails().

Tu recevras trois entrées : le nom du produit, le prix et le nombre d’années de garantie.

Formate le prix dans getDetails() afin d’afficher 2 décimales en utilisant String.format("%.2f", price). Observe attentivement la sortie : tu verras les messages des constructeurs apparaître dans l’ordre, montrant comment l’enchaînement se déroule de la classe parente à la classe enfant !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String name = scanner.nextLine();
        double price = scanner.nextDouble();
        int warrantyYears = scanner.nextInt();
        
        // TODO: Créer un objet Electronics en utilisant les trois paramètres
        
        // TODO: Afficher le résultat de getDetails()
    }
}