Turn Desktop View Off
by Dinesh Thakur

We saw that a class had only one constructor with either zero, one or more parameters. The constructor is key for object initialization. The mechanism of constructor is made considerable more powerful by combining with the feature of overloading. Constructor can be overloaded in exactly the same way as you can overload methods.

Constructor Overloading allows a class to have more than one constructor that have same name as that of the class but differs only in terms of number of parameters or parameter's datatype or both. By overloading a constructor for a class, we make the class more versatile as it allows you to construct objects in a variety of ways. In order to understand the concept of constructor overloading, let us consider the following example.

class Rectangle

{
      int length ;
      int breadth ;
        Rectangle()
        {
           System.out.println("Constructor with Zero Parameter Called ");
           length = breadth = 0 ;
         }
         Rectangle(int side)
         {
            System.out.println("Constructor with One Parameter Called");
            length = breadth = side ;
         }
         Rectangle(int l,int b)
         {
            System.out.println("Constructor with Two Parameters Called");
            length = l ;
            breadth = b ;
         }
         int area()
         {
           return (length * breadth) ;
         }
}
       class ConstructorOverloading
{
               public static void main(String[] args)
          {
                Rectangle r1 = new Rectangle(); //const. with 0-parameter called
                Rectangle r2 = new Rectangle(5); //const with l parameter called
                Rectangle r3 = new Rectangle(7,8); //const.with2 parameter called
                System.out.println("Area of First Rectangle is : "+ r1.area( ));
                System.out. println("Area of Square is : "+ r2.area( ));
                System.out.println("Area of Second Rectangle is : "+ r3.area( ));
          }
}

Constructor Overloading in Java with Example

In this example, the class Rectangle contains three constructors with the same name Rectangle which differs only in the number of parameters and hence overloaded.

The first constructor () doesn't take any parameter and initialize both data members to 0. The second constructor Rectangle (int a) takes a parameter a of int type and initialize both the data members length and breadth with a value of a. The third constructor Rectangle (int a, int b) takes two parameters a and b of int types which are used for initializing the data members length and breadth respectively.

Now we have defined three constructors associated with the class Rectangle. Which of these constructors will be executed when an object of rectangle class is created depends upon the number of arguments specified in the creation of an object.

On execution of the first statement Rectangle rl= new Rectangle () ; in main () , an object rl of type Rectangle is created and constructor with no parameter is called as no arguments are specified after rl object definition. It initializes both of its data members to a value 0 and displays the message Constructor with zero parameter called.

The statement Rectangle r2 == new Rectangle (5) ; creates an object r2 of type Rectangle and invokes a constructor with one parameter. As only one argument is specified after r2 object definition. Both the data members length and breadth of object r2 are initialized with the value 5 passed to single parameter constructor. It also displays the message Constructor with one parameter called on the console indicating the type of constructor being called.

The statement, Rectangle r3 =: new Rectangle (7 ,8) ; creates an object r3 of type Rectangle and invokes a constructor with two parameters. As two arguments are specified after r3 object definition. This constructor initialize the data members length and breadth with values of parameters a and b (i.e. 7 and 8) respectively. It also displays the message Constructor with two parameters called on the console indicating the type of constructor being called. Finally, these values are used to calculate the area of three rectangles represented by objects r1, r2 and r3.