Constructor Overloading in Java

In Java, we can overload constructors like methods. The constructor overloading allows a class to have multiple constructors with different parameter lists.

Important Points to Remember

• A class can have multiple constructors.
• Each overloaded constructor must have a different parameter list. The difference may lie in the number of parameters, the types of parameters, and the order of parameters.
• Overloaded constructor does not have any return type, not even void type.
• Overloading gives you the flexibility to create an object using various sets of starting values, or to use default values when some parameters are not specified automatically. It's a handy way to make your code more adaptable and user-friendly.
• Overloaded constructors can invoke other constructors within the same class using the this() keyword, which helps in reducing code duplication.

Example of Constructor Overloading

Consider the following Java program, which utilises different constructors within the class.

Output:

This is a default constructor
Default Constructor values: 
Student ID: 0
Student Name: null
Parameterized Constructor values: 
Student ID: 10
Student Name: David

Explanation

In the above example, the Main class constructor is overloaded with two different constructors: the default constructor and a parameterized constructor.

Here, we need to understand the purpose of constructor overloading. Sometimes, we need to use multiple constructors to initialize the different values of the class.

We must also note that the Java compiler invokes a default constructor when no constructor is specified in the class. However, the default constructor is not invoked if we have used any constructor in the class, whether it is default or parameterized. In this case, the Java compiler throws an exception stating that the constructor is undefined.

Consider the following example, which contains the error since the Colleges object cannot be created using the default constructor now, since it does not contain one.

Use of this() in Constructor Overloading

However, we can use this keyword inside the constructor to invoke the other constructor of the same class.

Consider the following example to understand the use of this keyword in constructor overloading.

Output:

Printing Student Information: 
Name: John
Id: 101
Contact No.: 9899234455
College Name: 9899234455
Passing Year: 2018

When Does Java Constructor Overloading Get Necessary?

In Java, a class can have more than one constructor specified with the same name but distinct parameters. Depending on the inputs provided, it enables the construction of objects with various sets of starting states, promoting flexibility in object initialisation.

Constructor overloading is necessary when a class needs to initialize different objects in different ways. For example, a class representing a geometric shape may contain constructors that take multiple parameters, including starting coordinates, colours, and dimensions. The overloading of constructors allows the class to handle different initialization conditions without requiring distinct method names.

To read more Difference Between Constructor Overloading and Method Overloading in Java

Advantages of Constructor Overloading

• Increases the readability and flexibility of code: Depending on the situation, constructor overloading enables several object initializations, which simplifies and clarifies the code.
• Reusable Code: It is possible to reuse common initialization code by using this() to invoke one constructor from another.
• An improved user experience: It makes the class easier to use by enabling the construction of objects with partial parameters, entire parameters, or default values.
• In support of polymorphism: The adaptability of the class is increased by overloading constructors, which act like polymorphic methods.
• Simpleness of Initializing an Object: Enables users to pass only the required parameters-not necessarily all fields-simplifying the process of creating objects.

Disadvantages of Constructor Overloading

• Enhanced Intricacy: Code that has too many overloaded constructors may be more difficult to read and maintain.
• Difficulties with Maintenance: It may be necessary to update other versions in order to add or change the constructor logic in one overloaded version, which would increase maintenance work.
• Possibility of Ambiguity: The compiler may become confused if constructors are not properly distinguished, particularly when nulls or comparable data types are used.
• Risk of Code Duplication: Similar code may be repeated over several constructors if it is not properly managed (for example, by employing this() chaining).
• More Challenging to Debug: It can be challenging to determine which overloaded constructor is being invoked when problems arise during object creation.

Java Constructor Overloading MCQs

1. Which of the following best describes constructor overloading?

1. Defining multiple constructors with the same signature.
2. Defining multiple constructors with different signatures.
3. Defining multiple constructors in different classes.
4. Defining constructors with the same number of parameters.

2. What will happen if a class has only parameterized constructors and no default constructor?

1. The compiler will provide a default constructor.
2. An error occurs if an object is created without parameters.
3. The class cannot be instantiated.
4. The parameterized constructor is called automatically.

3. What is the purpose of using this() in a constructor?

1. To call the superclass constructor.
2. To call another constructor in the same class.
3. To access instance variables.
4. To call static methods.

4. Can a constructor be synchronized in Java?

1. Yes
2. No
3. Only if it is a static constructor
4. Only if it is a private constructor

5. Which of the following is true about constructor overloading?

1. Overloaded constructors must call each other.
2. Overloaded constructors can have different access modifiers.
3. Overloaded constructors must be private.
4. Overloaded constructors cannot have more than one parameter.