Turn Desktop View Off
by Dinesh Thakur

Unlike default constructor which do not have any parameters, it is however possible to have one or more parameters in a constructor. This type of constructor which have parameters is known as parameterized constructor. Using parameterized constructor, it is possible to initialize objects with different set of values at the time of their creation. These different set of values initialized to objects must be passed as arguments when constructor is invoked. The parameter list can be specified in the parentheses in the same way as parameter list is specified in the method.

In order to understand the concept of parameterized constructor, let us again consider the Rectangle class in which we defined a zero parameter constructor to assign the same set of values to all the objects of the Rectangle class. But if we want to create objects of Rectangle class and initialize different set of values then we need to create a parameterized constructor as illustrated in the following example.

class Rectangle

      int length;
      int breadth;
      //constructor to initialize length and breadth of rectangle
      Rectangle(int l,int b)
      {
        length = l;
        breadth= b;
      }
      //method to calculate area of rectangle
      int area()
      {
         return (length * breadth);
      }
}
    //class to create rectangle objects and calculate area
    class ParameterizedConstructor
{
      public static void main(String[] args)
      {
        Rectangle firstRect = new Rectangle(5,6);
        Rectangle secondRect = new Rectangle(7,8);
        System.out.println("Area of First Rectangle  : " +firstRect.area());
        System.out.println("Area of Second Rectangle  : "+secondRect.area());
      }
}

Parameterized Constructor in Java Example

In this example, the class Rectangle contains a parameterized constructor. The specified values passed to this constructor are used to initialize instance variables length and breadth of an object. On the execution of the statement,

Rectangle firstRect = new Rectangle (5, 6);

the arguments 5 and 6 are passed to the parameters a and b of the Rectangle object's constructor which are then used to initialize length and breadth instance variables.

Similarly it works for the other object secondRect.

One of the another example

Calculate Area of Rectangle using Parameterised Constructor
import java.io.*;;
        class Rectangle
           {
               int l,b,a;
               Rectangle(int x, int y)
                  {
                     l = x;
                     b = y;
                  }
                    void GetArea()
                      {
                        a=l*b;
                        System.out.println("Area of Rectangle is : "+a);
                      }
           } 
                       class RectangleParameterisedConstructor
                         {
                             public static void main(String args[])
                             throws IOException
                              {
                                  BufferedReader  Br = new BufferedReader(new InputStreamReader(System.in));
                                  String lb;
                                  int Length,Breadth;
                                  System.out.println("Enter Length and Breadth");
                                  lb=Br.readLine();
                                  Length=Integer.parseInt(lb);
                                  lb=Br.readLine();
                                  Breadth=Integer.parseInt(lb);
                                  Rectangle Rect = new Rectangle(Length,Breadth);
                                  Rect.GetArea();
                              }
                        }

Area of Rectangle using Parameterised Constructor