此代码模式的目的是什么？

Question

I am debugging somebody else's code and I just don't understand the benefit of coding this way in Java.

I am not a Java Design Pattern expert but I would like to know when is this applicable?

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

Answer 1

This an implementation with few wrongs settings of builder pattern :

The intent of the Builder design pattern is to separate the construction of a complex object from its representation. By doing so the same construction process can create different representations.

What is strange here is that the constructor of the Builder class is called from MyClass . This is not generally done because ties the MyClass class to the Builder and not viceversa.

Additionally MyClass constructor should be private so that nobody can't access it directly, but only using the Builder .

The right implementation should be as follow:

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

Answer 2

According to the naming, this looks like one of the creational patterns - Builder pattern. However, this one is not well implemented.

The purpose of this pattern is to write readable and clean code to create a very complex object. A good and yet simple example is StringBuilder . It is often implemented with a fluent interface - a typical example is Stream<T> .

The correct implementation is for example here . It allows you to create an object using methods returning the builder. Example:

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

My personal point of view to this pattern:

It encourages to create and use complex objects. I prefer to refactor an object which has a builder with the smaller components. The object becomes easily testable and creatable through the constructors only.

Answer 3

The Builder pattern exposes what's called a Fluent API. Rather than individual set calls on each line, you can chain setters followed by a final build method to get the class instance. There's not typically getters on a builder object.

That constructor is a form of a copy constructor. I'm guessing there's other code using it to build unique instances of an object with the same data.

The last line of your main method isn't doing anything since you're not assigning that new class. In any case, as mentioned, you'd typically use a build method, not pass the builder into a constructor

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

MyClass.newBuilder() could also be replace by new MyClass.Builder()