Java constructors are special methods that are called when an object is instantiated. In other words, when you use the new keyword. The constructor initializes the newly created object. Here is a simple example that creates an object, which results in the class constructor being called:

EmployeeClass empClassObject 
            = new EmployeeClass();  

The above example results in a new EmployeeClass object being created, and also result in calling a special method (constructor) with zero arguments of EmployeeClass.

Defining a Constructor

Here is a simple Java constructor declaration example. The example shows a very simple Java class with a single constructor.

public  class EmployeeClass ()
{
   public EmployeeClass () {
  }
}

The constructor in the above code is

   
            public EmployeeClass () {
  }

In Java the constructor name has to be same name as the class. Also it is not required to declare a constructor in Java class. If you do not define any constructor in your class, java generates one for you by default. This constructor is known as default constructor.

Defining Multiple Constructors

A class can have multiple constructors, as long as their signature (the parameters they take) are not the same. You can define as many constructors as you need. When a Java class contains multiple constructors, we say that the constructor is overloaded (comes in multiple versions). This is what constructor overloading means, that a Java class contains multiple constructors.

Here is an e.g. of Java Class with multipe constructors

public class EmployeeClass{

	//Field 
	private String _firstName;
	private String _lastName; 	
	
	//Zero parameter constructor
	public EmployeeClass(){
		System.out.println("Zero parameter constructor has been called");

	}
	
	//2 parameter constructor
	public EmployeeClass(String fName , String lName ){
		System.out.println("2 parameter constructor has been called");
		
		//Initialize field values 
		this._firstName = fName;
		this._lastName = lName;
	}
	

  public static void main(String[] args) {
  	
   // Calling zero parameter constructor 
    EmployeeClass employeeObject1 = new EmployeeClass ();
    
    // Calling 2parameter constructor 
    EmployeeClass employeeObject2 = new EmployeeClass ("Sam" , "Harris");
    
  }
}

The Java class above contains two constructors. The first constructor is a no-arg constructor, meaning it takes no parameters. The second constructor takes two parameters. Inside the constructor body we initialize class fields _firstName and _lastName.

//Parent Class
public class Vehicle{
	public Vehicle () {
		System.out.println("Super class constructor has been called");
	}
}

public class Car extends Vehicle  {
	public Car () {
		System.out.println("Child class constructor has been called");
	}
	public static void main(String[] args) {
		Car car = new Car();
	}
}