Overloading Constructors and Constructor Chaining.

Note that:

• Having a private constructor in a class tells the compiler not to provide the default no-argument constructor.

• Private constructors can not be instantiated.

• this() must be the first non-commented statement in a constructor. Comments don't matter they are allowed anywhere.

What is construction overloading?

Constructor overloading in Java refers to the use of more than one constructor in an instance class. However, each overloaded constructor must have different signatures. For the compilation to be successful, each constructor must contain a different list of arguments.

You can have multiple constructors in the same class as long as they have different method signatures. When overloading methods, the method name and parameter list need to match. With constructors, the name is always the same since it has to be the same as the name of the class. Constructors must have different parameters in order to be overloaded.

 public class Hamster {
   private String color;
   private int weight;
   public Hamster(int weight) { // first constructor
      this.weight = weight;
      color = "brown";
   }
   public Hamster(int weight, String color) { // second constructor
      this.weight = weight;
      this.color = color;
   }
}

In the above, one of the constructors takes a single int parameter. The other takes an int and a String. These parameter lists are different, so the constructors are successfully overloaded.
There is a problem here, though. There is a bit of duplication. What we really want is for the first constructor to call the second constructor with
two parameters.

Constructor chaining
It is when overloaded constructors call each other. One common technique is to have each
constructor adds one parameter until getting to the constructor that does all the work.

public class Mouse {
   private int numTeeth;
   private int numWhiskers;
   private int weight;
   public Mouse(int weight) {
      this(weight, 16); // calls constructor with 2 parameters
   }
   public Mouse(int weight, int numTeeth) {
      this(weight, numTeeth, 6); // calls constructor with 3 parameters
   }
   public Mouse(int weight, int numTeeth, int numWhiskers) {
      this.weight = weight;
      this.numTeeth = numTeeth;
      this.numWhiskers = numWhiskers;
   }
   public void print() {
      System.out.println(weight + " " + numTeeth + " " + numWhiskers);
   }
   public static void main(String[] args) {
      Mouse mouse = new Mouse(15);
      mouse.print();
   }
}

result: 15 16 6

The main() method calls the constructor with one parameter. That constructor adds a second hard-coded value and calls the constructor with two
parameters. That constructor adds one more hard-coded value and calls the constructor
with three parameters. The three-parameter constructor assigns the instance variables.

Constructor chaining is used when you want to call a constructor
in another constructor.

Combined Benefits of Overloading and Chaining

Together, constructor overloading and chaining provide flexibility, efficiency, and maintainable code. Overloading allows you to support various initialization scenarios, while chaining ensures you can centralize shared logic and reduce redundancy.