A constructor in Java is a block of code similar to a method that’s called when an

instance of an object is created.

 Constructor will be called automatically when the object is created.

 Constructor name must be similar to name of the class.

 Constructor should not return any value even void also. Because basic aim is to
place the value in the object. (if we write the return type for the constructor then
that constructor will be treated as ordinary method).
 Constructor definitions should not be static. Because constructors will be called
each and every time, whenever an object is creating.

 It is basically used to initialize values for the object

In “Java” Constructors are basically divided into 3 types. They are

1. No argument Constructor
2. Argument Constructor
3. Copy Constructor

No Argument Constructor:-

 A Constructor that has no Parameter or argument is called “No Argument

Constructor”.
 Whenever we create an object “we does not pass any values from the object”
 It is also used to initialize values for the object
 It is Automatically called when we creates the object of class
 In this Constructor the programmer must remember name of Constructor is
same as name of class
 No argument Constructor never declared with the help of Return Type. Means
cant Declare a Constructor with the help of “void Return Type. “
 It is called by the JVM automatically itself whenever the programmer creates an
“Object”.

Syntax:
Classname()
{
Initialize values
}

Ex:
 Class addition
{
int a,b;

addition()
{
a=10;
b=20;
}

void display()
{
System.out.println(“Result “+(a+b));
}
}
Class student
{
Public static void main(String args[])
{
addition obj=new addition();
obj.display();
}
}

In the above example “addition” is class. When we create object

“obj” then the “JVM” automatically calls and initializes values in the constructor
“addition()”. This constructor does not contain any values at the time of object
creation because of this reason it is called “No argument Constructor”.

Argument Constructor:-

 A Constructor that has Parameter or argument is called “No Argument

Constructor”.
 Whenever we create an object “we pass values from the object”
 It is also used to initialize values for the object
 It is Automatically called when we creates the object of class
 In this Constructor the programmer must remember name of Constructor is
same as name of class
 Argument Constructor never declared with the help of Return Type. Means cant
Declare a Constructor with the help of “void Return Type. “
 It is called by the JVM automatically itself whenever the programmer creates an
“Object”.

Syntax:
Classname(parameterlist)
{
 Initialize values
}

Ex:

Class addition
{
int a,b;

addition(int x,int y)
{
a=x;
b=y;
}

void display()
{
System.out.println(“Result “+(a+b));
}
}
Class student
{
Public static void main(String args[])
{
addition obj=new addition(10,20);
obj.display();
}
}

In the above example “addition” is class. When we create object

“obj” then the “JVM” automatically calls and initializes values in the constructor
“addition(10,20)”. This constructor pass values 10,20 to the constructor in the
addition class. Here we pass parameters from the object that’s why it is called
“Argument Constructor”.

Copy Constructor:-

 A Constructor that copies values from another object is called “Copy Constructor”
 It Copies the values from either “No arugment Constructor” or “ Argument
Constructor”
 Some times it copies values from both of them
 Here we pass “Object” as a Paramter
 It is also used to initialize values for the object
 It is Automatically called when we creates the object of class
 In this Constructor the programmer must remember name of Constructor is
same as name of class
 Copy Constructor never declared with the help of Return Type. Means cant
Declare a Constructor with the help of “void Return Type. “
 It is called by the JVM automatically itself whenever the programmer creates an
“Object”.

Syntax:
Classname(classname Object)
{
Initialize values
}

Ex:

Class addition
{
int a,b;

addition(int x,int y)//parameterized constructor

{
a=x;
b=y;
}

addition(addition dobj)//copy constructor

{
a=dobj.a;
b=dobj.b;
}

void display()
{
System.out.println(“Result “+(a+b));
}
}
Class student
{
Public static void main(String args[])
{
addition obj1=new addition(10,20);//parameterized constructor
addition obj2=new addition(obj1);//copy constructor
obj1.display();
obj2.display();

}
}
 In the above example “addition” is class. When we create object
“obj1” then the “JVM” automatically calls and initializes values in the constructor
“addition(10,20)”. There after those values are copied by another object “obj2” with the
help of “copy Constructor” that is declared at “class addition”.

 There is no destructor in “Java”. Because “Java” has a feature called “Automatic

Garbage Collection”.
 Some times the programmer calls “protected void finalize()” for the sake of
garbage issue.