When constructor chaining, which constructor should the others call?

Question

When I have a class with multiple constructors where one constructor calls another one (constructor chaining), which constructor should be the one that all the other constructors call eventually?

Here's an example where the "all args" constructor calls the "no args" constructor:

class Goblin {
    // always starts at 10
    private int strength;
    private String name;

    public Goblin() {
        this.strength = 10;
    }

    public Goblin(String name) {
        this();
        this.name = name;
    }
}

Here's an example where the "no args" constructor calls the "all args" constructor

class Goblin {
    // always starts at 10
    private int strength;
    private String name;

    public Goblin() {
        this(null);
    }

    public Goblin(String name) {
        this.name = name;
        this.strength = 10;
    }
}

The idea is that there should be 1 place where this.strength = 10 and it won't have to be copied. Which of these is best?

Answer 1

I would advocate for preferring the second approach, as this allows you to declare both members as final and make the class formally immutable.

Answer 2

In general, it doesn't matter. The important thing is to chain the constructors so you're not repeating code. But if the no-arg one calls the one with arguments, or the one with args calls the no-arg one, they both accomplish the same thing - creating a (valid) object with no code repetition.

Answer 3

Your first approach only works as long as your default values and the default values for the datatype match.

If for example all goblins constructed with an empty constructor should be named "John", you need the second approach, otherwise you have this.name = in your code twice.

Answer 4

You should call the constructor with more args. This is called Constructor Delegation in C++ and the purpose it to reuse as much code as possible.