假设我有一个抽象类(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.

提前致谢.