DEV Community

Cover image for Overloading Constructors and Constructor Chaining.
Mercy
Mercy

Posted on

4 4 4 4 3

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;
   }
}
Enter fullscreen mode Exit fullscreen mode

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();
   }
}
Enter fullscreen mode Exit fullscreen mode

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.

AWS Security LIVE!

Tune in for AWS Security LIVE!

Join AWS Security LIVE! for expert insights and actionable tips to protect your organization and keep security teams prepared.

Learn More

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more

👋 Kindness is contagious

Explore a sea of insights with this enlightening post, highly esteemed within the nurturing DEV Community. Coders of all stripes are invited to participate and contribute to our shared knowledge.

Expressing gratitude with a simple "thank you" can make a big impact. Leave your thanks in the comments!

On DEV, exchanging ideas smooths our way and strengthens our community bonds. Found this useful? A quick note of thanks to the author can mean a lot.

Okay