Di seguito sono riportati alcuni motivi che sostengono l'uso del pattern e del codice di esempio in Java, ma è un'implementazione del Builder Pattern coperto da Gang of Four in Design Patterns . Le ragioni per cui lo useresti in Java sono applicabili anche ad altri linguaggi di programmazione.
Come afferma Joshua Bloch in Effective Java, 2nd Edition :
Il modello del costruttore è una buona scelta quando si progettano classi i cui costruttori o fabbriche statiche avrebbero più di una manciata di parametri.
Ad un certo punto tutti abbiamo incontrato una classe con un elenco di costruttori in cui ogni aggiunta aggiunge un nuovo parametro di opzione:
Pizza(int size) { ... }
Pizza(int size, boolean cheese) { ... }
Pizza(int size, boolean cheese, boolean pepperoni) { ... }
Pizza(int size, boolean cheese, boolean pepperoni, boolean bacon) { ... }
Questo è chiamato il modello del costruttore telescopico. Il problema con questo modello è che una volta che i costruttori sono lunghi 4 o 5 parametri, diventa difficile ricordare l' ordine richiesto dei parametri e quale costruttore specifico si potrebbe desiderare in una data situazione.
Un'alternativa è necessario il modello telescopica Constructor è il modello JavaBean cui si chiama un costruttore con i parametri obbligatori e quindi chiamare qualsiasi setter opzionali dopo:
Pizza pizza = new Pizza(12);
pizza.setCheese(true);
pizza.setPepperoni(true);
pizza.setBacon(true);
Il problema qui è che, poiché l'oggetto viene creato su più chiamate, potrebbe trovarsi in uno stato incoerente durante la sua costruzione. Ciò richiede anche uno sforzo supplementare per garantire la sicurezza della filettatura.
La migliore alternativa è utilizzare il Builder Pattern.
public class Pizza {
private int size;
private boolean cheese;
private boolean pepperoni;
private boolean bacon;
public static class Builder {
//required
private final int size;
//optional
private boolean cheese = false;
private boolean pepperoni = false;
private boolean bacon = false;
public Builder(int size) {
this.size = size;
}
public Builder cheese(boolean value) {
cheese = value;
return this;
}
public Builder pepperoni(boolean value) {
pepperoni = value;
return this;
}
public Builder bacon(boolean value) {
bacon = value;
return this;
}
public Pizza build() {
return new Pizza(this);
}
}
private Pizza(Builder builder) {
size = builder.size;
cheese = builder.cheese;
pepperoni = builder.pepperoni;
bacon = builder.bacon;
}
}
Si noti che la pizza è immutabile e che i valori dei parametri sono tutti in un'unica posizione . Poiché i metodi setter del Builder restituiscono l'oggetto Builder, possono essere concatenati .
Pizza pizza = new Pizza.Builder(12)
.cheese(true)
.pepperoni(true)
.bacon(true)
.build();
Ciò si traduce in un codice facile da scrivere e molto facile da leggere e comprendere. In questo esempio, il metodo di generazione potrebbe essere modificato per controllare i parametri dopo che sono stati copiati dal builder nell'oggetto Pizza e generare un'eccezione IllegalStateException se è stato fornito un valore di parametro non valido. Questo modello è flessibile ed è facile aggiungere ulteriori parametri in futuro. È davvero utile solo se hai più di 4 o 5 parametri per un costruttore. Detto questo, potrebbe essere utile in primo luogo se sospetti di poter aggiungere altri parametri in futuro.
Ho preso molto in prestito questo argomento dal libro Effective Java, 2nd Edition di Joshua Bloch. Per saperne di più su questo modello e altre pratiche Java efficaci, lo consiglio vivamente.