高效 Java 中的构建器模式

Question

我最近开始阅读 Joshua Bloch 所著的《Effective Java》。我发现 Builder 模式 [书中第 2 项] 的想法非常有趣。我尝试在我的项目中实现它，但出现编译错误。以下本质上是我想做的事情：

具有多个属性的类及其构建器类：

public class NutritionalFacts {
    private int sodium;
    private int fat;
    private int carbo;

    public class Builder {
        private int sodium;
        private int fat;
        private int carbo;

        public Builder(int s) {
            this.sodium = s;
        }

        public Builder fat(int f) {
            this.fat = f;
            return this;
        }

        public Builder carbo(int c) {
            this.carbo = c;
            return this;
        }

        public NutritionalFacts build() {
            return new NutritionalFacts(this);
        }
    }

    private NutritionalFacts(Builder b) {
        this.sodium = b.sodium;
        this.fat = b.fat;
        this.carbo = b.carbo;
    }
}

我尝试使用上述类的类：

public class Main {
    public static void main(String args[]) {
        NutritionalFacts n = 
            new NutritionalFacts.Builder(10).carbo(23).fat(1).build();
    }
}

我收到以下编译器错误：

包含的封闭实例 effectivejava.BuilderPattern.NutritionalFacts.Builder 是必须的 营养成分 n = 新 NutritionalFacts.Builder(10).carbo(23).fat(1).build();

我不明白该消息的含义。请解释一下。上面的代码与 Bloch 在他的书中建议的示例类似。

Answer 1

使构建器成为静态类。然后它就会起作用。如果它是非静态的，则它将需要其所属类的实例 - 重点是不要拥有它的实例，甚至禁止在没有构建器的情况下创建实例。

public class NutritionFacts {
    public static class Builder {
    }
}

参考：嵌套类

Answer 2

您应该将 Builder 类设置为静态，并且还应该将字段设置为最终字段，并使用 getter 来获取这些值。不要为这些值提供设置器。这样你的类将是完全不可变的。

public class NutritionalFacts {
    private final int sodium;
    private final int fat;
    private final int carbo;

    public int getSodium(){
        return sodium;
    }

    public int getFat(){
        return fat;
    }

    public int getCarbo(){
        return carbo;
    }

    public static class Builder {
        private int sodium;
        private int fat;
        private int carbo;

        public Builder sodium(int s) {
            this.sodium = s;
            return this;
        }

        public Builder fat(int f) {
            this.fat = f;
            return this;
        }

        public Builder carbo(int c) {
            this.carbo = c;
            return this;
        }

        public NutritionalFacts build() {
            return new NutritionalFacts(this);
        }
    }

    private NutritionalFacts(Builder b) {
        this.sodium = b.sodium;
        this.fat = b.fat;
        this.carbo = b.carbo;
    }
}

现在您可以按如下方式设置属性：

NutritionalFacts n = new NutritionalFacts.Builder().sodium(10).carbo(15).
fat(5).build();

Answer 3

要在 Intellij IDEA 中生成内部构建器，请查看此插件：https://github.com/analytically/innerbuilder

Answer 4

您正在尝试以静态方式访问非静态类。将 Builder 更改为 static class Builder ，它应该可以工作。

您提供的示例用法失败，因为不存在 Builder 实例。出于所有实际目的的静态类总是被实例化。如果您不将其设为静态，您需要说：

Widget = new Widget.Builder(10).setparm1(1).setparm2(3).build();

因为您每次都需要构造一个新的Builder。

Answer 5

您需要将 Builder 内部类声明为 static。

请查阅非静态内部类和静态内部类。

基本上，如果没有附加的外部类实例，非静态内部类实例就不能存在。

Answer 6

一旦你有了想法，在实践中，你可能会发现 lombok 的 @Builder 更方便。

@Builder 可让您自动生成使您的类可实例化所需的代码，例如：

Person.builder()
  .name("Adam Savage")
  .city("San Francisco")
  .job("Mythbusters")
  .job("Unchained Reaction")
 .build(); 

官方文档：https://www.projectlombok.org/features/Builder

Answer 7

这意味着您无法创建封闭类型。这意味着首先您必须创建“父”类的实例，然后从该实例您可以创建嵌套类实例。

NutritionalFacts n = new NutritionalFacts()

Builder b = new n.Builder(10).carbo(23).fat(1).build();

嵌套类

Answer 8

Builder 类应该是静态的。我现在没有时间实际测试除此之外的代码，但如果它不起作用，请告诉我，我会再看一下。

Answer 9

当你有两个不同的类时，我个人更喜欢使用另一种方法。所以你不需要任何静态类。这基本上是为了避免在必须创建新实例时编写 Class.Builder 。

public class Person {
    private String attr1;
    private String attr2;
    private String attr3;

    // package access
    Person(PersonBuilder builder) {
        this.attr1 = builder.getAttr1();
        // ...
    }

    // ...
    // getters and setters 
}

public class PersonBuilder (
    private String attr1;
    private String attr2;
    private String attr3;

    // constructor with required attribute
    public PersonBuilder(String attr1) {
        this.attr1 = attr1;
    }

    public PersonBuilder setAttr2(String attr2) {
        this.attr2 = attr2;
        return this;
    }

    public PersonBuilder setAttr3(String attr3) {
        this.attr3 = attr3;
        return this;
    }

    public Person build() {
        return new Person(this);
    }
    // ....
}

因此，您可以像这样使用您的构建器：

Person person = new PersonBuilder("attr1")
                            .setAttr2("attr2")
                            .build();

Answer 10

正如许多人已经指出的那样，您需要使类静态。
只是一点小小的补充 - 如果你愿意，有一种没有静态方法的不同方法。

考虑一下这一点。通过在类中声明类似 withProperty(value) 类型设置器的内容来实现构建器，并使它们返回对其自身的引用。在这种方法中，您有一个单一且优雅的类，它是线程安全且简洁的。

考虑一下：

public class DataObject {

    private String first;
    private String second;
    private String third;

    public String getFirst(){
       return first; 
    }

    public void setFirst(String first){
       this.first = first; 
    }

    ... 

    public DataObject withFirst(String first){
       this.first = first;
       return this; 
    }

    public DataObject withSecond(String second){
       this.second = second;
       return this; 
    }

    public DataObject withThird(String third){
       this.third = third;
       return this; 
    }
}


DataObject dataObject = new DataObject()
     .withFirst("first data")
     .withSecond("second data")
     .withThird("third data");

查看更多 Java Builder 示例。

Answer 11

您需要将Builder类更改为静态类Builder。然后它就会工作得很好。

Answer 12

其他解决方案将内存分配加倍以实例化对象。下面的解决方案就不存在这个问题。

public class NutritionalFacts{

    private int sodium;
    private int fat;
    private int carbo;

    private NutritionalFacts(){}

    public int getSodium(){ return sodium;}

    public int getFat(){ return fat;}

    public int getCarbo(){ return carbo;}

    public static class Builder{
        private NutritionalFacts nutrionalFacts;

        public Builder(){
           nutrionalFacts = new NutritionalFacts();
        }

        public Builder sodium(int s){
            nutrionalFacts.sodium = s;
            return this;
        }

        public Builder fat(int f){
            nutrionalFacts.fat = f;
            return this;
        }

        public Builder carbo(int c){
            nutrionalFacts.carbo = c;
            return this;
        }

        public NutritionalFacts build(){
            return nutrionalFacts;
        }
    }
}