Diciamo che ho una classe Dot con un costruttore:
public class Dot {
private final Double x;
private final Double y;
private final Color color;
private Dot(Double x, Double y, Color color) {
this.x = x;
this.y = y;
this.color = color;
}
public static Builder createBuilder() {
return new Builder();
}
public Double getX() { return x; }
public Double getY() { return y; }
public Color getColor() { return color; }
public Builder getBuilder() {
return new Builder().setX(x).setY(y).setColor(color);
}
public static class Builder {
private Double x;
private Double y;
private Color color;
public Builder setX(Double x) {
this.x = x;
return this;
}
public Builder setY(Double y) {
this.y = y;
return this;
}
public Builder setColor(Color color) {
this.color = color;
return this;
}
public Dot build() {
return new Dot(x, y, color);
}
}
}
Ora vedo due possibili modi per istanziare il costruttore. Attraverso il suo costruttore:
new Dot.Builder().setX(...
o tramite un metodo factory:
Dot.createBuilder().setX(...
(In quest'ultimo caso, renderei il Builder del costruttore private .)
Metodi di fabbrica (o fabbriche) sono (a mia conoscenza) utili quando il tipo effettivo del valore restituito potrebbe cambiare in seguito. Questo è qualcosa che probabilmente non si verificherà con un builder.
Il mio argomento migliore per usare un metodo factory potrebbe essere: Dì che il builder usa un campo finale String id che deve essere impostato nel suo costruttore, ma certe restrizioni si applicano a ciò che costituisce un ID. Lanciare un'eccezione su una stringa di ID illegale non dovrebbe essere fatto in un costruttore . Quindi un metodo factory sarebbe meglio.
Tuttavia, mi sembra di aver perso alcuni argomenti più importanti. Esiste una buona pratica per questo caso? Quali altri argomenti esistono per / contro l'utilizzo di un metodo di fabbrica qui?