假设我有一个抽象类(BaseThing).它具有一个必需参数(“基本必需”)和一个可选参数(“基本可选”).我有一个扩展它的具体类(事物).它还具有一个必需参数(“ required”)和一个可选参数(“ optional”).所以像这样:
public abstract class BaseThing {
public static final String DEFAULT_BASE_OPTIONAL = "Default Base Optional";
private final String baseRequired;
private String baseOptional = DEFAULT_BASE_OPTIONAL;
protected BaseThing(final String theBaseRequired) {
this.baseRequired = theBaseRequired;
}
final void setBaseOptional(final String newVal) {
this.baseOptional = newVal;
}
public final void selfDescribe() {
System.out.println("Base Required: " + baseRequired);
System.out.println("Base Optional: " + baseOptional);
selfDescribeHook();
}
protected abstract void selfDescribeHook();
}
和:
public final class Thing extends BaseThing {
public static final String DEFAULT_OPTIONAL = "Default Optional";
private final String required;
private String optional = DEFAULT_OPTIONAL;
Thing(final String theRequired, final String theBaseRequired) {
super(theBaseRequired);
required = theRequired;
}
@Override
protected void selfDescribeHook() {
System.out.println("Required: " + required);
System.out.println("Optional: " + optional);
}
void setOptional(final String newVal) {
optional = newVal;
}
}
我想要一个Thing对象的Joshua Bloch风格的生成器.不过,更笼统地说,我想让BaseThing的具体实现更容易具有构建器,因此,我真正想要的(我认为)是可以轻松用于构建ThingBuilder,OtherThingBuilder或SuperThingBuilder的BaseThing构建器. .
有没有比我提出的建议更好的方法(或者我提出的建议有问题)?
public abstract class BaseThingBuilder {
private String baseOptional = BaseThing.DEFAULT_BASE_OPTIONAL;
public BaseThingBuilder setBaseOptional(final String value) {
baseOptional = value;
return this;
}
public T build() {
T t = buildHook();
t.setBaseOptional(baseOptional);
return t;
}
protected abstract T buildHook();
}
和:
public final class ThingBuilder extends BaseThingBuilder {
private final String baseRequired;
private final String required;
private String optional = Thing.DEFAULT_OPTIONAL;
public ThingBuilder(final String theRequired,
final String theBaseRequired) {
required = theRequired;
baseRequired = theBaseRequired;
}
public ThingBuilder setOptional(final String value) {
optional = value;
return this;
}
protected Thing buildHook() {
Thing thing = new Thing(required, baseRequired);
thing.setOptional(optional);
return thing;
}
}
可用于构建Thing对象的方式类似于以下内容:
BaseThingBuilder builder =
new ThingBuilder("Required!", "Base Required!")
.setOptional("Optional!")
.setBaseOptional("Base Optional!");
Thing thing = builder.build();
thing.selfDescribe();
哪个输出:
Base Required: Base Required!
Base Optional: Base Optional!
Required: Required!
Optional: Optional!
我知道的一个问题,但我认为不是特别重要(尽管可以改进,这样做很好),因为在设置任何基本选项之前必须先设置所有非基本选项:否则会导致语法错误,因为setBaseOptional()返回BaseThingBuilder而不是ThingBuilder.
提前致谢.