Java 生成器模式的抽象类

我现有的模型类总是使用生成器模式，如下所示：

public class Model {
    public static class Builder {
        private boolean isValid;
        private List<String> errorMessagesOrNull;

        public Builder setIsValid(final boolean isValid) {
            this.isValid = isValid;
            return this;
        }

        public Builder setErrorMessages(final List<String> errorMessages) {
            this.errorMessagesOrNull = errorMessages;
            return this;
        }

        public List<String> getErrorMessages() {
            return this.errorMessagesOrNull == null ? new ArrayList<>() : this.errorMessagesOrNull;
        }

        public Model Build() {
            return new Model(this);
        }
    }

    private boolean isValid;
    private List<String> errorMessages;

    private Model(final Builder builder) {
        this.isValid = builder.isValid;
        this.errorMessages = builder.getErrorMessages();
    }

    public boolean getIsValid() {
        return isValid;
    }

    public List<String> getErrorMessages() {
        return errorMessages;
    }
}

但它并没有像我想的那样起作用。当我扩展抽象类时：

public abstract class AbstractModel<T extends AbstractModel<T>> {

    public static abstract class Builder<T> {
        private boolean isValid;
        private List<String> errorMessagesOrNull;

        public Builder<T> setIsValid(final boolean isValid) {
            this.isValid = isValid;
            return this;
        }

        public Builder<T> setErrorMessages(final List<String> errorMessages) {
            this.errorMessagesOrNull = errorMessages;
            return this;
        }

        public List<String> getErrorMessages() {
            return this.errorMessagesOrNull == null ? new ArrayList<>() : this.errorMessagesOrNull;
        }

        public abstract T Build();
    }

    private boolean isValid;
    private List<String> errorMessages;

    private AbstractModel(final Builder<T> builder) {
        this.isValid = builder.isValid;
        this.errorMessages = builder.getErrorMessages();
    }

    public boolean getIsValid() {
        return isValid;
    }

    public List<String> getErrorMessages() {
        return errorMessages;
    }
}

public class Model extends AbstractModel<Model> {
    // Empty here since all fields are extended
}

我希望抽象类有

Builder

静态类，这样我就不需要每次都编写静态类

Builder

---

请告知。

我认为你的逻辑有一个巨大的缺陷。这个程序本身毫无意义。为什么首先要用

Builder

类构造

模型

？我认为最好是向你展示你应该如何编写你的程序，而不是只是把它“混在一起”。好的，让我们从

模型开始

import organisation.projectname.pathToBuilder.Builder.Model;

假设没有
生成器
就无法构造
模型
类。然后将
Builder
类添加到
Model
类中有意义吗？简短回答：不，不会。相反，
Builder
类应该包含作为非静态内部类的
Model
类

/**
 * The {@code Builder} can construct new instances of the {@code Model} class.
 *
 * @see Model
 */
public class Builder
{
    private final String[] log;

    /**
     * The {@code Model} class can do something. You can only construct it through a {@code Builder}.
     *
     * @see Builder
     */
    public class Model
    {
        private final Builder builder;

        /**
         * Constructs a new {@code Model} with the specified argument.
         *
         * @param builder the {@code Builder} that constructed the model.
         */
        public Model(final Builder builder)
        {
            this.builder = builder;
        }

        /**
         * Returns the associated {@code Builder}.
         *
         * @return the builder that constructed the model.
         */
        public Builder getBuilder()
        {
            return this.builder;
        }
    }

    /**
     * Constructs a new instance of the {@code Builder} class with the specified argument.
     *
     * @param log the log of the {@code Builder}.
     */
    public Builder(final String... log)
    {
        this.log = log;
    }

    /**
     * Tries to {@code build} a new instance of the {@code Model} class.
     *
     * @return the constructed {@code Model}.
     */
    public Model build()
    {
        return new Model(this);
    }

    /**
     * Returns the log of the {@code Builder}.
     *
     * @return an log.
     */
    public String[] getLog()
    {
        return this.log;
    }

    /**
     * Determines whether or not the {@code Builder} is valid.
     *
     * @return {@code true} when the specified {@code log} is not {@code null}; {@code false} otherwise.
     */
    public boolean isValid()
    {
        return this.log != null;
    }
}

除了
生成器
之外，任何类都不能构造
模型
。但是，如果您构造了
Builder
类的新实例并获得调用
build
方法的结果，那么您将可以访问所有
public
变量和方法

如果您知道要构建一个
模型
，您可以这样做：

Builder.Model model = new Builder().build();

如果不需要
Builder.
前缀，只需添加导入
Model
类的导入语句即可

import organisation.projectname.pathToBuilder.Builder.Model;

您还需要实现
Builder

public class Model extends AbstractModel<Model>{


    private Model(final Builder builder) {
        super(builder);
    }

    public static class Builder2 extends AbstractModel.Builder<Model> {

        @Override
        public Model Build() {
            return new Model(this);
        }
    }
}

编辑

此外，AbstractBuilder的构造函数也必须受到
保护

  protected AbstractModel(final Builder<? extends Builder<T>> builder) {
        this.isValid = builder.isValid;
        this.errorMessages = builder.getErrorMessages();
    }

受保护的抽象模型（最终构建者
Model
类甚至没有
扩展
AbstractModel
类。@Theikon我更新了问题-抱歉，但请看一看，为什么您首先将其设置为内部和静态？我想这只是我的首选@YassinHajajThanks的回答-但是
模型有一个错误de>class:
隐式超级构造函数AbstractModel（）默认构造函数未定义。必须定义显式构造函数。
。我做错了什么？没关系！请教育我：谢谢你的建议！我将不同的帖子标记为答案，因为它与原始问题更相关。但我也对你的答案投了赞成票。我非常感谢你的帖子：）谢谢！这正是我想要的。而且我不需要
protectedabstractmodel（最终构建器）
  protected AbstractModel(final Builder<? extends Builder<T>> builder) {
        this.isValid = builder.isValid;
        this.errorMessages = builder.getErrorMessages();
    }