Constructor Overloading in Java

What Constructor Overloading in Java?

Java Constructor overloading is a technique in which a class can have any number of constructors that differ in parameter list. The compiler differentiates these constructors by taking into account the number of parameters in the list and their type.

Examples of valid constructors for class Account are

Account(int a);
Account (int a,int b);
Account (String a,int b);

Example 2: To understand Constructor Overloading in Java

Step 1) Type the code in the editor.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

Step 2) Save, Compile & Run the Code.

Step 3) Error = ?. Try and debug the error before proceeding to next step of Java constructor overloading

Step 4) Every class has a default Constructor in Java. Default overloaded constructor Java for class Demo is Demo(). In case you do not provide this constructor the compiler creates it for you and initializes the variables to default values. You may choose to override this default constructor and initialize variables to your desired values as shown in Example 1.

But if you specify a parametrized constructor like Demo(int a), and want to use the default constructor Java Demo(), it is mandatory for you to specify it.

In other words, in case your overloading constructor in Java is overridden, and you want to use the default constructor Java, its need to be specified.

Step 5) Uncomment line # 4-8. Save, Compile & Run the code.

Why do we need Constructor Overloading in Java?

Constructor overloading in Java allows multiple constructors in a class, each having different parameter lists. It enhances flexibility and improves code efficiency.

• Flexibility in Object Creation: Constructor overloading allows you to initialize objects in various ways, depending on the number or type of parameters.
• Code Reusability: You can reuse constructor logic by calling one constructor from another using the this() keyword.
• Improved Readability: Overloaded constructors help make the code more intuitive by offering specific constructor options for different initialization needs.
• Default and Custom Initialization: Constructor overloading allows you to create both default and custom-initialized objects easily.

FAQs

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Inside Constructor
Value1 === 10
Value2 === 20

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

super();
--or--
super(parameter list);

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4