使用Builder模式扩展类

问题描述

我正在尝试将类a扩展为aX。所以，我也扩展了aBuilder。但是，虽然我能够使用以下方法创建类a的对象：

I am trying to extend a class a, into aX. So, I also extend aBuilder. However, while I am able to create an object of class a using :

aBuilder f = new aBuilder();
f.bi = i;
f.bs = s;
a atry = f.withI(i).withS(s).build();

同样不适用于aX。当我尝试这样做时：

The same doesn't work for aX. When I try to do this :

aXBuilder fb = new aXBuilder();
aX aXtry = fb.withI(i).withS(s).withB(b).build();

我收到错误（对于a.aBuilder类型，未定义withB（Boolean）方法）。
我应该改写aX的所有东西，而不是简单地添加新的东西吗？我不想这样做，因为这会导致我的代码中出现大量重复。 a和aX类如下：

I get an error (The method withB(Boolean) is undefined for the type a.aBuilder).Should I instead rewrite all the stuff for aX, instead of simply adding new stuff? I don't want to do that because that will lead to a lot of duplicacy in my code. The classes a and aX are as given below:

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);
    }

}

}

class aX扩展了一个{

class aX extends a {

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);
    }
}

}

推荐答案

您可以使用泛型来解决问题，尽管它确实需要创建抽象超类。潜伏在这个网站上告诉我，从一个具体类继承被广泛认为是邪恶的。

You can solve your problem with generics, although it does require creation of an abstract superclass. Lurking on this site has taught me that inheriting from a concrete class is widely considered to be evil.

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;
        }
    }
}

一旦你有了抽象类在一起，您可以根据需要多次扩展它，覆盖构建器中的抽象方法以返回所需对象的类型。

Once you have your abstract class together, you just extend it as many times as you need, overriding the abstract methods in the builder to return the type of object you need.

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;
        }
    }
}

然后......
ConcreteA baz = new ConcreteA.Builder（）。withFoo（foo）。withS（bar）。withI（0）.build（）;

这篇关于使用Builder模式扩展类的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！