Question

I have a class called RawReader that reads the bytes of some resource, parses them, then writes files to an output directory.

It makes sense to allow different types to be passed in as the source and destination to the constructor.

• Source: String (of file or URL), URL, File or InputStream
• Destination: String (directory) or File

However if I overload the constructor that leaves me with 8 different versions. If I wanted to add a third optional argument for example chunkSize I’d have 16 constructors!

On the other hand I could just have two constructors accepting (Object, Object) and (Object, Object, int). The argument types could be detected and an IllegalArgumentExceptions thrown if they aren’t correct.

How are situations like this normally handled in Java?

Answer 1

You can use a builder:

Foo foo = new FooBuilder().setFile(..).setChunkSize().build();

Where .build() invokes a constructor of Foo that takes the builder and assigns whichever variables are set. Something like that:

public class Foo {

private Foo(FooBuilder builder) {
    //get whatever you can find from the builder to fill the state of Foo
}
public static FooBuilder {
     private String filename;
     private File file;
     private InputStream stream;
     private int chunkSize;
     // getters and setters
     public Foo build() {
         return new Foo(this);
     }
}

}