Constructor Parameters - Rule of Thumb

Question

In general, what is the maximum number of parameters a class constructor should accept? I'm developing a class that requires a lot of initialization data (currently 10 parameters). However, a constructor with 10 parameters doesn't feel right. That leads me to believe I should create a getter/setter for each piece of data. Unfortunately, the getter/setter pattern doesn't force the user to enter the data and without it characterization of the object is incomplete and therefore useless. Thoughts?

Answer 1

With that many parameters, it's time to consider the Builder pattern. Create a builder class which contains all of those getters and setters, with a build() method that returns an object of the class that you're really trying to construct.

Example:

public class ReallyComplicatedClass {     private int int1;     private int int2;     private String str1;     private String str2;     // ... and so on     // Note that the constructor is private     private ReallyComplicatedClass(Builder builder) {         // set all those variables from the builder     }     public static class Builder {         private int int1;         private int int2;         private String str1;         private String str2;         // and so on          public Builder(/* required parameters here */) {             // set required parameters         }         public Builder int1(int newInt) {             int1 = newInt;             return this;         }         // ... setters for all optional parameters, all returning 'this'         public ReallyComplicatedClass build() {             return new ReallyComplicatedClass(this);         }     } } 

And in your client code:

ReallyComplicatedClass c = new ReallyComplicatedClass.Builder()         .int1(myInt1)         .str2(myStr2)         .build(); 

See pages 7-9 of Effective Java Reloaded [pdf], Josh Bloch's presentation at JavaOne 2007. (This is also item 2 in Effective Java 2nd Edition, but I don't have it handy so I can't quote from it.)