A constructor is a special method that is called whenever an object is created using the new keyword. It contains a block of statements that is used to initialize instance variables of an object before the reference of this object is returned by new. Constructor can be defined as a method having same name as class name without any return type.
Important Note: A constructor does look and feel a lot like a method but it is different from a method in two ways:
Table of Contents
Initializing a variable is very helpful while making programs. We can initialize variables of primitive types at the time of their declarations. For example:
int a=10;
In object oriented programming language (OOPL) like java, the need of initialization of fields of a new object is even more common. It can be done by using following two approaches:
A better solution to the above problems is to initialize values to the object at a time of its creation in the same way as we initialize values to the variable of primitive data types. This is accomplished using a special method in java known as constructor that makes an object to initialize itself at the time of its creation without the need to make separate call to the instance method.
The syntax of constructor is as follows:
ConstructorName([parameterList])
{
//constructor body
}
Here, the constructorName is same as the name of class it belongs to.
The parameterList is the list of optional zero or more parameters that are specified after the class name in the parenthesis. Each parameter specification, if any, consists of a type and a name and are separated from each other by commas.
Let us consider the program that gives us the use of constructor to initialize the instance variables of the newly created object.
Firstly we make a class Rectangle in which we declare constructor and method to show how to use it:
//use of constructor
class Rectangle
{
int length;
int breadth;
//declare constructor to initialize length and breadth of rectangle
Rectangle()
{
length=5;
breadth=6;
}
//declare method to calculate area of rectangle
int area()
{
int rectArea=length*breadth;
return rectArea;
}
}
Then we create a class ConstructorDemo which inherits the above class Rectangle and is used to create objects of the Rectangle class and calculate its area:
//class to create a rectangle objects and calculate area
class ConstructorDemo
{
public static void main(String args[])
{
Rectangle r=new Rectangle();
System.out.println("Area of rectangle="+r.area());
}
}
Output:
Area of rectangle= 30
Explanation:
There are three types of constructors. These are:
Below we have describe all three constructor in detail with example:
Each time an object is created, a constructor is always invoked. But in some programs if we don’t create any constructor. So in such situations, the compiler automatically creates one constructor which is known as default constructor. It does not contain any parameters and doesn’t even contain any statements in its body. Its only purpose is to enable you to create object of class type. The default constructor looks like:
public Rectangle(){}
Important Note: Constructors are invoked only after the instance variables of a newly created object of the class have been assigned their default initial values and after their explicit initializers are executed.
Program Example of Default Constructor:
Let us consider a program to demonstrate the use of the default values, initialize expressions and constructors.
Firstly we create a class Display in which we declare default constructor:
class Display
{
int a=6; //initializer expression
int b=5; //initializer expression
int c; //assigned default value
Display()
{
a=4; //override default and initializer expression
}
void show()
{
System.out.println("Value of a="+a);
System.out.println("Value of b="+b);
System.out.println("Value of c="+c);
}
}
Then we create a class DisplayDemo which inherits the methods from above class Display:
class DisplayDemo
{
public static void main(String args[])
{
Display data=new Display();
data.show();
}
}
Output:
Value of a= 4 Value of b= 5 Value of c= 0
The constructor which has parameters is known as parameterized constructor. Using parameterized constructor, it is possible to initialize objects with different set of values at 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 parenthesis in the same way as parameter list is specified in the method.
Program Example of Parameterized Constructor:
Let us consider a program to understand the concept of parameterized constructor.
First we make a class Rectangle in which we declare the parametrized constructor:
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);
}
}
Second we create a class ParamConstructorDemo which inherit the methods of above class Rectangle and create the object of Rectangle class and calculate its area:
//class to create a rectangle objects and calculate area
class ParamConstructorDemo
{
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());
}
}
Output:
Area of first rectangle= 30 Area of second rectangle= 56
Sometimes a programmer wants to create an exact but separate copy of an existing object so that any changes to the copy should not alter the original or vice versa. This is made possible by using the copy constructor. A copy constructor is a constructor that creates a new object that is using an existing object of the same class and initializes each instance variable of newly created object with corresponding instance variables of the existing object passed as argument. This constructor takes a single argument whose type is that of the class containing the constructor.
Program Example of Copy Constructor:
Let us consider a program in which we create a copy of an existing object.
First we create a class Rectangle in which we declare the copy constructor to initialize length and breadth:
class Rectangle
{
int length;
int breadth;
//constructor to initialize length and breadth of rectangle
Rectangle(int l, int b)
{
length=l;
breadth=b;
}
//copy constructor
Rectangle(Rectangle obj)
{
System.out.println("copy constructor invoked");
length=obj.length;
breadth=obj.breadth;
}
//method to calculate area of rectangle
int area()
{
return (length*breadth);
}
}
Second we create a class CopyConstructorDemo which inherit the methods of above class Rectangle and create its object and calculate area:
//class to create a rectangle objects and calculate area
class CopyConstructorDemo
{
public static void main(String args[])
{
Rectangle firstRect=new Rectangle(5,6);
Rectangle secondRect=new Rectangle(firstRect);
System.out.println("Area of first rectangle="+firstRect.area());
System.out.println("Area of second rectangle="+secondRect.area());
}
}
Output:
Copy constructor invoked Area of first rectangle= 30; Area of second rectangle= 30;
Constructor can be overloaded in 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 data type 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.
Program Example of Constructor Overloading:
In order to understand the concept of constructor overloading, let us consider the following program.
First we create class Rectangle in which we declare more than one constructor of same name to show constructor overloading:
//constructor overload
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);
}
}
Second we create class ConstructorOverload which inherits the above class Rectangle:
class ConstructorOverload
{
public static void main(String args[])
{
Rectangle r1=new Rectangle();
Rectangle r2=new Rectangle(5);
Rectangle r3=new Rectangle(7,8);
System.out.println("Area of first rectangle="+r1.area());
System.out.println("Area of square="+r2.area());
System.out.println("Area of second rectangle="+r3.area());
}
}
Output:
Constructor with zero parameter called Constructor with one parameter called Constructor with two parameters called Area of first rectangle= 0 Area of square= 25 Area of second rectangle= 56
Explanation of Example:
In the above program, the class Rectangle contains three constructor with the same name Rectangle which differ only in the number of parameters and hence overloaded.
Premium Project Source Code:
Leave a Reply