Patron Monteur

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

Le pattern Builder est un patron de conception créationnel qui résout un problème courant : construire des objets complexes avec de nombreux paramètres facultatifs. Au lieu de créer plusieurs constructeurs ou de transmettre null pour les paramètres inutilisés, le Builder vous permet de construire des objets étape par étape.

Imaginez créer un objet User avec des champs obligatoires (nom, e-mail) et des champs facultatifs (âge, téléphone, adresse). Sans Builder, vous auriez besoin de constructeurs télescopiques ou d’un constructeur peu pratique avec de nombreux paramètres. Le modèle Builder offre une approche plus claire :

public class User {
    private final String name;    // requis
    private final String email;   // requis
    private final int age;        // optionnel
    private final String phone;   // optionnel
    
    private User(UserBuilder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
    }
    
    public static class UserBuilder {
        private final String name;
        private final String email;
        private int age;
        private String phone;
        
        public UserBuilder(String name, String email) {
            this.name = name;
            this.email = email;
        }
        
        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }
        
        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }
        
        public User build() {
            return new User(this);
        }
    }
}

Les méthodes du Builder renvoient this, ce qui permet le chaînage des méthodes : une manière fluide et lisible de construire des objets :

User user = new User.UserBuilder("Alice", "alice@email.com")
    .age(25)
    .phone("555-1234")
    .build();

Remarquez que le constructeur User est privé : les objets peuvent uniquement être créés par l’intermédiaire du Builder. Ce modèle est particulièrement utile lorsque les objets possèdent de nombreux champs facultatifs, ce qui rend votre code plus lisible et moins sujet aux erreurs que de longues listes de paramètres.

Défi

Facile

Construisons un système de commande de pizzas en utilisant le patron Builder ! Au lieu de gérer un constructeur qui accepte des dizaines de paramètres pour toutes les garnitures et options possibles, vous allez créer un builder fluide qui rend la personnalisation des pizzas claire et lisible.

Vous allez organiser votre code dans deux fichiers :

Pizza.java : créez une classe Pizza qui utilise le patron Builder pour sa construction. Votre pizza doit posséder les champs suivants :
size (String) - obligatoire, représente la taille de la pizza

cheese (boolean) - facultatif, vaut false par défaut

pepperoni (boolean) - facultatif, vaut false par défaut

mushrooms (boolean) - facultatif, vaut false par défaut

Le constructeur de Pizza doit être privé et accepter uniquement un PizzaBuilder comme paramètre, en copiant toutes les valeurs du builder dans les champs de la pizza.

Incluez une méthode getDescription() qui renvoie une chaîne dans ce format : [size] Pizza with: [toppings], où toppings est une liste séparée par des virgules des garnitures dont la valeur est true (Cheese, Pepperoni, Mushrooms). Si aucune garniture n'est sélectionnée, la partie toppings doit simplement indiquer no toppings.

Créez une classe interne statique PizzaBuilder avec :
- Un constructeur qui accepte le paramètre obligatoire size
- Les méthodes cheese(), pepperoni() et mushrooms(), qui définissent chacune la valeur booléenne correspondante sur true et renvoient this pour permettre l'enchaînement
- Une méthode build() qui renvoie une nouvelle instance de Pizza
Main.java : mettez votre builder de pizza à l'épreuve ! Vous recevrez quatre entrées : la taille de la pizza (String) et trois valeurs yes/no (Strings) indiquant respectivement s'il faut ajouter du fromage, du pepperoni et des champignons.
Créez un PizzaBuilder avec la taille donnée. Ensuite, en fonction de chaque entrée yes/no, enchaînez les méthodes de garniture appropriées. Si l'entrée est "yes", appelez la méthode de cette garniture ; si elle est "no", ignorez-la. Enfin, appelez build() pour créer votre pizza.

Affichez le résultat de l'appel à getDescription() sur votre pizza terminée.

Vous recevrez quatre entrées dans l'ordre suivant : taille (String), ajouter du fromage (String : "yes" ou "no"), ajouter du pepperoni (String : "yes" ou "no"), ajouter des champignons (String : "yes" ou "no").

Par exemple, avec les entrées Large, yes, no, yes, votre sortie serait : Large Pizza with: Cheese, Mushrooms

Remarquez comment le patron Builder vous permet de construire des pizzas avec n'importe quelle combinaison de garnitures sans avoir besoin de constructeurs distincts pour chaque possibilité !

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 size = scanner.nextLine();
        String addCheese = scanner.nextLine();
        String addPepperoni = scanner.nextLine();
        String addMushrooms = scanner.nextLine();
        
        // TODO: Créer un PizzaBuilder avec la taille donnée
        // TODO: Enchaîner les méthodes de garniture selon les entrées oui/non
        // TODO: Construire la pizza et afficher sa description
        
    }
}