Brief Overview:
The constructor in Java play a very important role in object oriented programming , In this post I discuss in detail how constructors are used in Java programming language with an example.
Constructor
It is a special type of method , used to initialise the values of data members of class . We can do this in different ways .
Construtor Types
Default
In this case , all data members are initialised to zero or null ,we can call this explicitly or the compiler will do it automatically.
Example :
class A{
int a, b ;
string str;
public A(){
a=b=0;
str=NULL;
}
}
In the above example ,we initialised the class data members to 0
Parametrised
class Example
{
private int var;
//default constructor
public Example()
{
this.var = 10;
}
//parameterized constructor
public Example(int num)
{
this.var = num;
}
public int getValue()
{
return var;
}
public static void main(String args[])
{
Example obj = new Example();
Example obj2 = new Example(100);
System.out.println("var is: "+obj.getValue());
System.out.println("var is: "+obj2.getValue());
}
}
The code above illustrates the initialising the values of a, b and str (class members) to x ,y and str1.
Copy Constructor
class Complex {
private double re, im;
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
//copy constructor
Complex(Complex c) {
System.out.println("Copy constructor called");
re = c.re;
im = c.im;
}
public String toString() {
return "(" + re + " + " + im + "i)";
}
}
public class Main {
public static void main(String[] args) {
Complex c1 = new Complex(10, 15);
Complex c2 = new Complex(c1);
Complex c3 = c2;
System.out.println(c2);
}
}
The complex number are initialised through the objects.
The Java supports all the above discussed constructors.
Constructor Overloading
Constructor name is same as class same , each constructor will differ by its type and number of arguments. The following example illustrate :
Class test{
int a,b;
string str;
public test(){
a = b =0;
str=0;
}
public test(int x,int y)
{
a=x;
b=y;
}
}
public class main class{
public static void main(String args[])
{
test t1 = new test();//object creation which calls default constructor .
test t2 = new test(2,4);//Second Object creation creates parametrised constructor.
Constructors in Inheritance
In inheritance ,we use the constructor extensively for the data initialisation , super() is used to access the super class constructor . The following example clarify the usage of the constructors in inheritance.
class Person1
{
Person1()
{
System.out.println("Person1 class Constructor");
}
}
/* subclass Student extending the Person class */
class Student1 extends Person1
{
Student1()
{
// invoke or call parent class constructor
super();
System.out.println("Student1 class Constructor");
}
}
class Test
{
public static void main(String[] args)
{
Student1 s = new Student1();
}
}
Output

In inheritance we can initialise the data members through super() and directly calling the parent class constructor.
- Call to super() should be the first statement in Derived Class constructor.
- If a constructor does not explicitly calls a superclass constructor, the Java compiler automatically inserts a call to the zero-argument constructor of the superclass. If the superclass does not have a zero-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.
- If a subclass constructor calls a constructor of its superclass, either explicitly or implicitly, we might think that a whole chain of constructors called one by one , all the way back to the constructor of Object. This is called constructor chaining.
Constructor Chaining
Consider a situation where a base class is extended by a child class. Whenever an object of the child class is created, the constructor of the super class is invoked first before the child class constructor . It is called Constructor chaining.
class DemoChain{
int value1;
int value2;
DemoChain(){
value1 = 1;
value2 = 2;
System.out.println("Inside 1st Parent Constructor");
}
DemoChain(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 DemoChain{
int value3;
int value4;
DemoChild(){
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);
}
}

Conclusion
The constructors plays a important role in data initialisation , the concept is little bit complicated ,but the above example clearly clarify the concepts of constructors in inheritance .
Image by wikipedia.