Essentially, a constructor serves as a unique type of method that initializes the object during its creation. Whenever the new() keyword is employed to create an object, at least one constructor is invoked.The Java compiler will automatically provide a default constructor if a class does not provide a specific constructor.

The term "constructor" originates from its function of constructing or building the object's value at the time of its creation. Declaring a constructor is not mandatory every time a class is created since the Java compiler will supply a default constructor when necessary.

Rules for creating Java constructor

• The constructor(s) name in object-oriented programming must have the same name as the class name in which constructor is define
• Java does not allow final, abstract, static, or synchronised constructors.
• In order to regulate the constructor's access, access modifiers can be used in its declaration.

Types of constructor

• There are two types of constructor in Java:
  • Default constructor(No argument)
  • Parameterized constructor

Default constructor

• Default Constructor is a constructor which doesn't have any parameter.
• The compiler creates a constructor for a class without any arguments if a constructor is not defined in the class. The compiler does not produce a default constructor for you if you define a constructor.
• Depending on the type, the default constructor gives the object default values like 0, null, etc. For example, Consider a "Person" class with member variables like "name" (a string) and "age" (an integer). when a new "Person" object is created using the default constructor then it would typically initialize the "name" variable to null and the "age" variable to 0

How to declare program using default constructor

 // Java  program using default constructor  

public class Student   
{  
    int Id;
    public Student() {
        System.out.println("Your ID is "+Id);
    }
    public static void main(String[] args) {
        Student student =new Student(); // when object is created constructor automatically invoked 
    }
} 

0  

Parameterized constructor

• Constructors with parameters are referred to as parameterized constructors. They enable you to provide specific values during object creation to initialise a class's fields. By employing a parameterized constructor, you can create your own default values based on the arguments passed for the class's fields.

How to define Parameterized constructors

 // Java  program using class and object   

class Student{  
	public static void main(String args[]){  
		int x = 10;  
		int y = 20;  		
		int z = addition(x, y);   //Here x and y are actual parameters  & add method is called
		System.out.println("The sum of x and y is = " + z);  
	}  
		
	public static int addition(int a, int b)   //a and b are formal parameters 
        // Here Method is static so that we can access without object
	{  
		int sum;  
		sum=a+b;  
		return sum; //returning the sum  
	}
}  
 

The sum of x and y is = 30  

In the above example, we have used add method it is not already define so we have define it first and access in main method, we have made add method static because we can access static method without object. you wil learn about static method below this page

Constructor Overloading in Java

Method overloading refers to when a class has multiple methods with the same name but different parameter lists.

Example of Constructor Overloading

 // Constructor Overloading  program  

class Addition{  
	Addition(int x,int y){
		System.out.println("Sum of two number is : "+(x+y));
	}  
	Addition(int p,int q,int r){
		System.out.println("Sum of three number is : "+(p+q+r));
	}  
} 
class code_check{  
	public static void main(String args[]){  
          Addition addition=new Addition(12,13);
          Addition addition2=new Addition(12,13,15);
	}  
}

Sum of two number is : 25 

Sum of three number is : 40 

Java Copy Constructor

In Java, there are various methods available for copying the values of one object into another.

• There are two types of constructor in Java:
  • By constructor
  • By assigning the values of one object into another
  • By clone() method of Object class

Java Copy Constructor

 // Java  program using class and object   

class codeCheck{
    int roll;
    String name; 
    codeCheck(int roll, String name) 
    {
    	this.roll = roll;
    	this.name = name;
    }
    codeCheck(codeCheck object)  //constructor to initialize another object
    {
    	roll = object.roll;  // object is object of  codeCheck class
	    name =object.name;
    }
    void display(){
    	System.out.println(roll+" "+name);
    }
 
    public static void main(String args[]) {
    	codeCheck code1 = new codeCheck(8650,"Dr Alok Raja");		
    	codeCheck code2 = new codeCheck(code1);   
    	code1.display();
	code2.display();
   }
}

8650 Dr Alok Raja 

8650 Dr Alok Raja 

Comparison Chart

Difference between constructor and method in Java are mention below