Pattern Builder

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 67 di 87.

Il Builder Pattern è un pattern di progettazione creazionale che risolve un problema comune: costruire oggetti complessi con molti parametri facoltativi. Invece di creare più costruttori o passare null per i parametri non utilizzati, il Builder ti permette di costruire gli oggetti passo dopo passo.

Considera di creare un oggetto User con campi obbligatori (nome, email) e facoltativi (età, telefono, indirizzo). Senza un Builder, dovresti usare costruttori telescopici o un costruttore poco pratico con molti parametri. Il pattern Builder offre un approccio più pulito:

public class User {
    private final String name;    // obbligatorio
    private final String email;   // obbligatorio
    private final int age;        // facoltativo
    private final String phone;   // facoltativo
    
    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);
        }
    }
}

I metodi di Builder restituiscono this, consentendo il concatenamento dei metodi: un modo scorrevole e leggibile per costruire oggetti:

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

Nota che il costruttore User è privato: gli oggetti possono essere creati solo tramite il Builder. Questo schema è particolarmente utile quando gli oggetti hanno molti campi facoltativi, rendendo il codice più leggibile e meno soggetto a errori rispetto a lunghe liste di parametri.

Sfida

Facile

Costruiamo un sistema per ordinare pizze usando il Builder Pattern! Invece di avere a che fare con un costruttore che accetta decine di parametri per tutti i possibili condimenti e le opzioni, creerai un builder fluente che rende la personalizzazione della pizza semplice e leggibile.

Organizzerai il codice in due file:

Pizza.java: crea una classe Pizza che usa il Builder Pattern per la costruzione. La pizza dovrà avere i seguenti campi:
size (String) - obbligatorio, rappresenta la dimensione della pizza

cheese (boolean) - facoltativo, il valore predefinito è false

pepperoni (boolean) - facoltativo, il valore predefinito è false

mushrooms (boolean) - facoltativo, il valore predefinito è false

Il costruttore di Pizza deve essere privato e accettare solo un PizzaBuilder come parametro, copiando tutti i valori dal builder ai campi della pizza.

Includi un metodo getDescription() che restituisce una stringa in questo formato: [size] Pizza with: [toppings], dove toppings è un elenco separato da virgole dei condimenti impostati su true (Cheese, Pepperoni, Mushrooms). Se non viene selezionato alcun condimento, la parte toppings deve riportare semplicemente no toppings.

Crea una classe interna statica PizzaBuilder con:
- Un costruttore che accetta il parametro obbligatorio size
- I metodi cheese(), pepperoni() e mushrooms(), ognuno dei quali imposta il rispettivo booleano su true e restituisce this per consentire il concatenamento
- Un metodo build() che restituisce una nuova Pizza
Main.java: mostra il funzionamento del tuo builder per le pizze! Riceverai quattro input: la dimensione della pizza (String) e tre valori sì/no (String) che indicano rispettivamente se aggiungere cheese, pepperoni e mushrooms.
Crea un PizzaBuilder con la dimensione specificata. Poi, in base a ciascun input sì/no, concatena i metodi appropriati per i condimenti. Se l'input è "yes", chiama il metodo corrispondente al condimento; se è "no", saltalo. Infine, chiama build() per creare la pizza.

Stampa il risultato della chiamata a getDescription() sulla pizza completata.

Riceverai quattro input nell'ordine seguente: dimensione (String), aggiungere cheese (String: "yes" o "no"), aggiungere pepperoni (String: "yes" o "no"), aggiungere mushrooms (String: "yes" o "no").

Ad esempio, con gli input Large, yes, no, yes, il tuo output sarebbe: Large Pizza with: Cheese, Mushrooms

Nota come il Builder Pattern ti permette di costruire pizze con qualsiasi combinazione di condimenti, senza dover creare costruttori separati per ogni possibilità!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leggi gli input
        String size = scanner.nextLine();
        String addCheese = scanner.nextLine();
        String addPepperoni = scanner.nextLine();
        String addMushrooms = scanner.nextLine();
        
        // TODO: Crea un PizzaBuilder con la dimensione indicata
        // TODO: Concatena i metodi per aggiungere i condimenti in base agli input yes/no
        // TODO: Costruisci la pizza e stampa la sua descrizione
        
    }
}