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 démontre le chaînage de constructeurs à la fois au sein d'une classe et à travers une hiérarchie d'héritage. Vous verrez comment this() chaîne les constructeurs dans la même classe, tandis que super() chaîne vers les constructeurs parents.

Vous allez créer trois fichiers pour organiser votre code :

Product.java : Créez 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 à la fois le nom et le prix, initialise les champs et affiche : Product constructor: [name]
- Un deuxième constructeur qui ne prend que le nom et se chaîne au constructeur principal en utilisant this(name, 0.0) pour définir un prix par défaut de 0.0
- Des méthodes getName() et getPrice() pour accéder aux champs
Electronics.java : Créez une sous-classe qui étend Product et ajoute des informations de garantie :
- Un champ privé pour warrantyYears (int)
- Un constructeur principal qui prend le nom, le prix et warrantyYears - utilisez super(name, price) pour initialiser le parent, puis définissez la garantie et affichez : Electronics constructor: [warrantyYears] year warranty
- Un deuxième constructeur qui ne prend que le nom et le prix, se chaînant au constructeur principal avec this(name, price, 1) pour fournir une garantie par défaut de 1 an
- Un troisième constructeur qui ne prend que le nom, se chaînant au deuxième constructeur avec this(name, 0.0)
- Une méthode getDetails() qui retourne : [name] - $[price] ([warrantyYears] year warranty)
Main.java : Démontrez le chaînage de constructeurs en action. Vous recevrez trois entrées : un nom de produit (String), un prix (double) et les années de garantie (int). Créez un objet Electronics en utilisant les trois paramètres, puis affichez le résultat de getDetails().

Vous recevrez trois entrées : le nom du produit, le prix et les années de garantie.

Formatez le prix dans getDetails() pour afficher 2 décimales en utilisant String.format("%.2f", price). Observez attentivement la sortie - vous verrez les messages des constructeurs apparaître dans l'ordre, montrant comment la chaîne circule du parent vers l'enfant !

Aide-mémoire

Le chaînage de constructeurs est le processus consistant à appeler un constructeur à partir d'un autre pour éviter la duplication de code.

Chaînage au sein de la même classe

Utilisez this() pour appeler un autre constructeur dans la même classe :

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;
    }
}

Chaînage dans l'héritage

Utilisez super() pour appeler le constructeur de la classe parente. Il doit s'agir de la première ligne du constructeur :

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");
    }
}

Si vous n'appelez pas explicitement super(), Java insère automatiquement super() (la version sans argument). Les constructeurs parents sont toujours appelés avant les constructeurs enfants, garantissant ainsi un ordre d'initialisation correct.

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()
    }
}