Ho difficoltà a valutare un'implementazione del modello di build che ho appena creato.
Il contesto è una libreria API, quindi sto cercando di non esporre alcuna implementazione per avere un'interfaccia stabile e poter cambiare le implementazioni in seguito.
Il mio pensiero è che anche se c'è un riferimento all'implementazione nel file dell'interfaccia, l'interfaccia e l'implementazione non sono effettivamente accoppiate perché
In effect, a static nested class is behaviorally a top-level class...
Il vantaggio di questo design è che i client possono chiamare
Person person = new Person.Builder().age(20).firstName("John")
.lastName("Doe").build();
senza bisogno di una classe di tipo Factory dedicata.
Mi manca qualcosa o si tratta di una decisione di progettazione valida?
Person.java
package net.mhi.rd;
public interface Person {
int getAge();
String getFirstName();
String getLastName();
public static class Builder {
int age;
String firstName;
String lastName;
public Builder age(int age) {
this.age = age;
return this;
}
public Builder firstName(String firstName) {
this.firstName = firstName;
return this;
}
public Builder lastName(String lastName) {
this.lastName = lastName;
return this;
}
public Person build() {
return new PersonImpl(this);
}
}
}
PersonImpl.java
package net.mhi.rd;
class PersonImpl implements Person {
private final int age;
private final String firstName;
private final String lastName;
PersonImpl(Person.Builder builder) {
this.age = builder.age;
this.firstName = builder.firstName;
this.lastName = builder.lastName;
}
@Override
public int getAge() {
return age;
}
@Override
public String getFirstName() {
return firstName;
}
@Override
public String getLastName() {
return lastName;
}
}
