title: Improvements to Joshua Bloch's Builder Design Pattern?
body: <p>Back in 2007, I read an article about Joshua Blochs take on the "builder pattern" and how it could be modified to improve the overuse of constructors and setters, especially when an object has a large number of properties, most of which are optional. A brief summary of this design pattern is articled here [http://rwhansen.blogspot.com/2007/07/theres-builder-pattern-that-joshua.html].</p>
  
  <p>I liked the idea, and have been using it since. The problem with it, while it is very clean and nice to use from the client perspective, implementing it can be a pain in the bum! There are so many different places in the object where a single property is reference, and thus creating the object, and adding a new property takes a lot of time.</p>
  
  <p>So...I had an idea. First, an example object in Joshua Bloch's style:</p>
  
  <p>Josh Bloch Style:</p>
  
  <pre><code>public class OptionsJoshBlochStyle {
  
      private final String option1;
      private final int option2;
      // ...other options here  &lt;&lt;&lt;&lt;
  
      public String getOption1() {
          return option1;
      }
  
      public int getOption2() {
          return option2;
      }
  
      public static class Builder {
  
          private String option1;
          private int option2;
          // other options here &lt;&lt;&lt;&lt;&lt;
  
          public Builder() {
          }
  
          public Builder option1(String option1) {
              this.option1 = option1;
              return this;
          }
  
          public Builder option2(int option2) {
              this.option2 = option2;
              return this;
          }
  
          public OptionsJoshBlochStyle build() {
              return new OptionsJoshBlochStyle(this);
          }
      }
  
      private OptionsJoshBlochStyle(Builder builder) {
          this.option1 = builder.option1;
          this.option2 = builder.option2;
          // other options here &lt;&lt;&lt;&lt;&lt;&lt;
      }
  
      public static void main(String[] args) {
          OptionsJoshBlochStyle optionsVariation1 = new OptionsJoshBlochStyle.Builder().option1("firefox").option2(1).build();
          OptionsJoshBlochStyle optionsVariation2 = new OptionsJoshBlochStyle.Builder().option1("chrome").option2(2).build();
      }
  }
  </code></pre>
  
  <p>Now my "improved" version:</p>
  
  <pre><code>public class Options {
  
      private String option1;
      private int option2;
      // ...other options here
  
      public String getOption1() {
          return option1;
      }
  
      public int getOption2() {
          return option2;
      }
  
      public static class Builder {
  
          private final Options options;
  
          public Builder() {
              this.options = new Options();
          }
  
          public Builder option1(String option1) {
              this.options.option1 = option1;
              return this;
          }
  
          public Builder option2(int option2) {
              this.options.option2 = option2;
              return this;
          }
  
          public Options build() {
              return options;//new RequestContext(this);
          }
      }
  
      private Options() {
  
      }
  
      public static void main(String[] args) {
          Options optionsVariation1 = new Options.Builder().option1("firefox").option2(1).build();
          Options optionsVariation2 = new Options.Builder().option1("chrome").option2(2).build();
  
      }
  }
  </code></pre>
  
  <p>As you can see in my "improved version", there are 2 less places in which we need to add code about any addition properties (or options, in this case)! The only negative that I can see is that the instance variables of the outer class are not able to be final. But, the class is still immutable without this.</p>
  
  <p>Is there really any downside to this improvement in maintainability? There has to be a reason which he repeated the properties within the nested class that I'm not seeing?</p>
  
  <p>PS: Not sure if this is an appropriate type of question for StackOverflow or belongs on something more subjective like [programmers.stackexchange.com], so I apologize in advance!</p>
  
  <p>EDIT 1:</p>
  
  <p>@irreputable - Something like this in Java? I still don't see how this becomes thread safe, because of the change. I'll have to look into safe publishing, as you suggest.</p>
  
  <pre><code>public class OptionsDelegate {
  
      private final OptionsData data;
  
      private static class OptionsData {
           String option1;
           int option2;
      }
  
      // ...other options here
  
      public String getOption1() {
          return data.option1;
      }
  
      public int getOption2() {
          return data.option2;
      }
  
      public static class Builder {
  
          private OptionsData data;
  
          public Builder() {
              this.data = new OptionsData();
          }
  
          public Builder option1(String option1) {
              this.data.option1 = option1;
              return this;
          }
  
          public Builder option2(int option2) {
              this.data.option2 = option2;
              return this;
          }
  
          public OptionsDelegate build() {
              OptionsDelegate optionsDelegate = new OptionsDelegate(this.data);
              this.data = null;
              return optionsDelegate;
          }
      }
  
      private OptionsDelegate(OptionsData data) {
          this.data = data;
      }
  
      public static void main(String[] args) {
          OptionsDelegate optionsVariation1 = new OptionsDelegate.Builder().option1("firefox").option2(1).build();
          OptionsDelegate optionsVariation2 = new OptionsDelegate.Builder().option1("chrome").option2(2).build();
  
  
      }
  }
  </code></pre>