Java 这个代码模式的目的是什么？

我正在调试别人的代码，但我不明白用Java这种方式编码的好处

我不是Java设计模式专家，但我想知道这什么时候适用

public class MyClass {

    public static class Builder {
        //Getters and setters
    }

    public static Builder newBuilder() {
        return new Builder();
    }

    public MyClass(Builder builder) {
        //More Methods
    }

    public static void main(String[] args) {
        MyClass.Builder builder = MyClass.newBuilder();
        new MyClass(builder);
    }
}

---

构建器模式公开了所谓的Fluent API。您可以将setter与最终构建方法链接起来，以获取类实例，而不是在每一行上进行单独的set调用。生成器对象上通常没有getter

该构造函数是复制构造函数的一种形式。我猜还有其他代码使用它来构建具有相同数据的对象的唯一实例

主方法的最后一行没有执行任何操作，因为您没有分配新类。在任何情况下，如前所述，您通常使用构建方法，而不是将构建器传递给构造函数

MyClass foo = MyClass.newBuilder()
    .withBar("blah")
    .build();

---

MyClass.newBuilder（）

也可以被

newmyclass.Builder（）

替换。生成器模式公开了所谓的Fluent API。您可以将setter与最终构建方法链接起来，以获取类实例，而不是在每一行上进行单独的set调用。生成器对象上通常没有getter

该构造函数是复制构造函数的一种形式。我猜还有其他代码使用它来构建具有相同数据的对象的唯一实例

主方法的最后一行没有执行任何操作，因为您没有分配新类。在任何情况下，如前所述，您通常使用构建方法，而不是将构建器传递给构造函数

MyClass foo = MyClass.newBuilder()
    .withBar("blah")
    .build();

---

MyClass.newBuilder（）

也可以被

new MyClass.Builder（）

替换，这是一个实现，设置错误很少：

构建器设计模式的目的是将复杂对象的构造与其表示分离。通过这样做，相同的构造过程可以创建不同的表示

奇怪的是，

Builder

类的构造函数是从

MyClass

调用的。通常不会这样做，因为将

MyClass

类绑定到

Builder

而不是反之亦然

另外，

MyClass

构造函数应该是

private

，这样任何人都不能直接访问它，只能使用

Builder

正确的实施应如下所示：

public class MyClass {
    // Often fields are final to create an immutable class
    private final String fieldA;

    // Private constructor using Builder to set inner fields
    // To create MyClass you have to use Builder
    private MyClass(Builder builder) {
        // Setting fields from builder
        this.a = builder.getFieldA();
    }

    public static class Builder {
       // Fields on Builder are not final
       private String fieldA;

       //Getters and setters

       // Method to set field of builder
       public Builder setFieldA(String a) {
          this.a = a;
          return this;   // Returning this to chain setters
       }

    ...
        // Method to instantiate MyClass
        public MyClass build() {
           return new MyClass(this);
        }
    }
}

// Calling it as follow
MyClass a = new MyClass.Builder()
                .setFieldA("value")
                .setFieldB("value")
                .build();

---

这是一个很少有错误设置的实现：

构建器设计模式的目的是将复杂对象的构造与其表示分离。通过这样做，相同的构造过程可以创建不同的表示

奇怪的是，

Builder

类的构造函数是从

MyClass

调用的。通常不会这样做，因为将

MyClass

类绑定到

Builder

而不是反之亦然

另外，

MyClass

构造函数应该是

private

，这样任何人都不能直接访问它，只能使用

Builder

正确的实施应如下所示：

public class MyClass {
    // Often fields are final to create an immutable class
    private final String fieldA;

    // Private constructor using Builder to set inner fields
    // To create MyClass you have to use Builder
    private MyClass(Builder builder) {
        // Setting fields from builder
        this.a = builder.getFieldA();
    }

    public static class Builder {
       // Fields on Builder are not final
       private String fieldA;

       //Getters and setters

       // Method to set field of builder
       public Builder setFieldA(String a) {
          this.a = a;
          return this;   // Returning this to chain setters
       }

    ...
        // Method to instantiate MyClass
        public MyClass build() {
           return new MyClass(this);
        }
    }
}

// Calling it as follow
MyClass a = new MyClass.Builder()
                .setFieldA("value")
                .setFieldB("value")
                .build();

---

根据命名，这看起来像一个创造性的模式-构建器模式。然而，这一点并没有得到很好的实施

此模式的目的是编写可读且干净的代码来创建非常复杂的对象。一个很好但很简单的例子是。它通常通过一个流畅的界面来实现——一个典型的例子是

例如，正确的实现是。它允许您使用返回生成器的方法创建对象。例如：

MyClass foo = MyClass.newBuilder()
    .cached()
    .with(new Feature1())
    .with(new Feature2())
    .foo()
    .bar()
    .build();

我个人对这种模式的看法是：

它鼓励创建和使用复杂对象。我更喜欢重构一个具有较小组件的构建器的对象。该对象仅通过构造函数就可以轻松地进行测试和创建

---

根据命名，这看起来像一个创造性的模式-构建器模式。然而，这一点并没有得到很好的实施

此模式的目的是编写可读且干净的代码来创建非常复杂的对象。一个很好但很简单的例子是。它通常通过一个流畅的界面来实现——一个典型的例子是

例如，正确的实现是。它允许您使用返回生成器的方法创建对象。例如：

MyClass foo = MyClass.newBuilder()
    .cached()
    .with(new Feature1())
    .with(new Feature2())
    .foo()
    .bar()
    .build();

我个人对这种模式的看法是：

它鼓励创建和使用复杂对象。我更喜欢重构一个具有较小组件的构建器的对象。该对象仅通过构造函数就可以轻松地进行测试和创建

---

看起来像是一个实现得很差的构建器模式。或者，它的实现是正确的，而您只是遗漏了相关部分。虽然将构建器作为参数的构造函数看起来很愚蠢，可能是由一个不是“Java设计模式专家”的人实现的。@Kayaman实际上我自己把main方法放进去了。如果不做我在主方法中所做的事情，我想不出实例化这个类的方法，对吗？有很多移动的代码会把我的问题弄得一团糟，所以我去掉了很多。在正确的构建器模式中，你没有访问构造函数的权限，创建实例的唯一方法是通过构建器对象（使用一些

build（）

方法）。@Kayaman我很好奇。。那么下面的说法也被认为是错误的？我想这就是我所看到的代码所遵循的模式。@Kayaman，我不确定我接受的答案是否也是正确的。。因为即使是他的代码也在构造函数中接受一个构建器。看起来像是一个实现糟糕的构建器模式。或者，它的实现是正确的，而您只是遗漏了相关部分。虽然将构建器作为参数的构造函数看起来很愚蠢，可能是由一个不是“Java设计模式专家”的人实现的。@Kayaman实际上我自己把main方法放进去了。我想不出一个没有你的方法来实例化这个类