Constructor Chaining in Java

Question

When creating multiple constructors, I usually do the following;

public ConstructorName(int count)
{
    this(count, 0);
}

public ConstructorName(String count)
{
    this(Integer.parseInt(count), 0);
}

public ConstructorName(int count, int other)
{
    // Do something here
}

However, I can also do it this way;

public ConstructorName(String count)
{
    this(Integer.parseInt(count)); // Chain to the constructor that just takes a number
}

public ConstructorName(int count)
{
    this(count, 0);
}

public ConstructorName(int count, int other)
{
    // Do something here
}

Is there any actual difference here? Which would be better to use when coding?

Answer 1

Doesn't answer the question directly, but its far more better not to overload constructors/function

Instead of constructor overloading you should make the construtor private and call it from public static functions which do start with "create" or something like that.

For example:

class ClassName
{
    static public ClassName createFromCountString(string count)
    {
        return new ClassName(Integer.parseInt(count), 0);
    }

    static public ClassName createFromCount(int count)
    {
        return new ClassName(count, 0);
    }

    static public ClassName createFromCountAndOther(int count, int other)
    {
        return new ClassName(count, other);
    }

    private ClassName(int count, int other)
    {
        // do something here
    }
}

Answer 2

If there is more than one way to construct an instance, then static factory methods backed by one private constructor, can really help readability, since they can be named differently.

Range halfOpen = Range.largerThan(5);
Range closed = Range.between(7, 12);

If it is really about setting some properties and not others, then the Builder pattern can be what you want.

Person john = Person.named("John")
    .lastName("Lennon")
    .gender(Male)
    .yearOfBirth(1940)
    .build();

Both of these approaches also allow for hiding which implementation class is really returned. Our Person instance may be an instance of subclass Man, and the half open Range may be an instance of HalfOpenRange. Both methods allow returning a cached instance, rather than an actual new instance.