我正在尝试将 a 类扩展到 aX 中。所以,我也扩展了aBuilder。然而,虽然我能够使用以下命令创建类 a 的对象:
aBuilder f = new aBuilder();
f.bi = i;
f.bs = s;
a atry = f.withI(i).withS(s).build();
同样的情况对于 aX 不起作用。当我尝试这样做时:
aXBuilder fb = new aXBuilder();
aX aXtry = fb.withI(i).withS(s).withB(b).build();
我收到错误(对于 a.aBuilder 类型,方法 withB(Boolean) 未定义)。
我应该重写 aX 的所有内容,而不是简单地添加新内容吗?我不想这样做,因为这会导致我的代码出现很多重复。 a 类和 aX 类如下所示:
class a {
protected String s;
protected int i;
public void getdata() {
System.out.println(this.s);
System.out.println(this.i);
}
protected a(aBuilder fb) {
this.s = fb.bs;
this.i = fb.bi;
}
public static class aBuilder {
public aBuilder() {
}
protected String bs;
protected int bi;
public aBuilder withS(String s) {
this.bs = s;
return this;
}
public aBuilder withI(Integer i) {
this.bi = i;
return this;
}
public a build() {
return new a(this);
}
}
}
类 aX 扩展了 {
protected Boolean b;
public void getData()
{
System.out.println(this.s);
System.out.println(this.i);
System.out.println(this.b);
}
protected aX(aXBuilder axb) {
super(axb);
this.b = axb.bb;
}
public static class aXBuilder extends aBuilder {
protected Boolean bb;
public aXBuilder() {
}
public aXBuilder withB(Boolean b) {
this.bb = b;
return this;
};
public aX build() {
return new aX(this);
}
}
}
您可以使用泛型解决您的问题,尽管它确实需要创建抽象超类。潜伏在这个网站上告诉我,从具体类继承被广泛认为是邪恶的。
public abstract class AbstractA {
protected String s;
protected int i;
protected AbstractA() {
}
protected abstract static class ABuilder<T extends AbstractA, B extends ABuilder<T,B>> {
protected T object;
protected B thisObject;
protected abstract T getObject(); //Each concrete implementing subclass overrides this so that T becomes an object of the concrete subclass
protected abstract B thisObject(); //Each concrete implementing subclass builder overrides this for the same reason, but for B for the builder
protected ABuilder() {
object = getObject();
thisObject = thisObject();
}
public B withS(String s) {
object.s = s;
return thisObject;
}
public B withI(int i) {
object.i = i;
return thisObject;
}
public T build() {
return object;
}
}
}
一旦你有了抽象类,你只需根据需要多次扩展它,重写构建器中的抽象方法即可返回你需要的对象类型。
public final class ConcreteA extends AbstractA {
private String foo;
protected ConcreteA() {
}
public static final class Builder extends AbstractA.ABuilder<ConcreteA,Builder> {
@Override protected ConcreteA getObject() {
return new ConcreteA();
}
@Override protected Builder thisObject() {
return this;
}
public Builder() {
}
public Builder withFoo(String foo) {
object.foo = foo;
return this;
}
}
}
Then...
ConcreteA baz = new ConcreteA.Builder().withFoo("foo").withS("bar").withI(0).build();
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)