JavaScript constructor format similarity for Java

Updated

I originally misread this answer, which describes the idiom for this from Effective Java 2nd Edition. I thought it didn't do something it does do, and so this answer is really just a duplicate of that answer (except that that answer's syntax was better). I've marked this answer as a CW.

I'm leaving this intact, though, since it was apparently of some use to the OP. But I'm posting the other answer's syntax below.

The solution from Effective Java 2nd Edition is to have the constructor accept an "options" object using the builder pattern (Foo.Options below). This is so the real object is either fully-constructed or not constructed, but never half-constructed; the Foo.Options instance may be half-constructed, but we don't care as it's just an options class. This also lets us put the logic around duplicated options or missing options in a nice separate (but contained) class.

Here's what it looks like to use: (but note that the Effective Java syntax is even simpler, see below)

Foo f = new Foo((new Foo.Options()).first("primero").second("secondo"));

(Foo could also provide a positional-arguments constructor if desired, as an option, for callers who wanted to use that; see note after the big code block.)

Here's what Foo (and Foo.Options) look like:

public class Foo {

    public Foo(Foo.Options opts) {
        if (!opts.isValid()) {
            // Throw exception
        }

        // Use options
    }

    public static class Options {
        private String _first = null;
        private String _second = null;

        public Options() {
        }

        public Options(String f, String s) {
            this.first(f).second(s);
        }

        public boolean isValid() {
            return this._first != null && this._second != null;
        }

        public Options first(String f) {
            this._first = f;
            return this;
        }

        public String getFirst() {
            return this._first;
        }

        public Options second(String s) {
            this._second = s;
            return this;
        }

        public String getSecond() {
            return this._second;
        }
    }
}

Of course, if you also wanted to allow positional arguments, you could define a Foo constructor accepting them. To avoid having arguments logic repeated in both Foo and Foo.Options, that constructor would probably just call the Foo.Options version, e.g.:

// *Optional* additional positional constructor for `Foo`
public Foo(String first, String second) {
    this((new Foo.Options()).first(first).second(second));
}

Here's the code and usage from the answer I misread originally. The big difference is that instead of Foo.Options, we have Foo.Builder, and Foo.Builder returns a Foo when we ask it to build:

Foo foo = Foo.builder()
    .setColor(red)
    .setName("Fred")
    .setSize(42)
    .build();

Here's Foo and Foo.Builder:

public class Foo {
  public static class Builder {
    public Foo build() {
      return new Foo(this);
    }

    public Builder setSize(int size) {
      this.size = size;
      return this;
    }

    public Builder setColor(Color color) {
      this.color = color;
      return this;
    }

    public Builder setName(String name) {
      this.name = name;
      return this;
    }

    // you can set defaults for these here
    private int size;
    private Color color;
    private String name;
  }

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

  private Foo(Builder builder) {
    size = builder.size;
    color = builder.color;
    name = builder.name;
  }

  private final int size;
  private final Color color;
  private final String name;

  // The rest of Foo goes here...
}