https://beginnersbook.

com/2013/03/constructors-in-java/

Constructor is a block of code that initializes the newly created object. A

constructor resembles an instance method in java but it’s not a method as it
doesn’t have a return type. In short constructor and method are different. People
often refer constructor as special type of method in Java.

Constructor has same name as the class and looks like this in a java code.

public class MyClass{

//This is the constructor
MyClass(){
}
..
}

Note that the constructor name matches with the class name and it doesn’t have
a return type.

How does a constructor work

To understand the working of constructor, lets take an example. lets say we have
a class MyClass.
When we create the object of MyClass like this:

MyClass obj = new MyClass()

The new keyword here creates the object of class MyClass and invokes the

constructor to initialize this newly created object.

A simple constructor program in java

Here we have created an object obj of class Hello and then we displayed the
instance variable nameof the object. As you can see that the output
is BeginnersBook.com which is what we have passed to the name during initialization
in constructor. This shows that when we created the object obj the constructor got
invoked. In this example we have used this keyword, which refers to the current
object, object obj in this example.
https://beginnersbook.com/2013/03/constructors-in-java/

public class Hello {

String name;
//Constructor
Hello(){
this.name = "Beginners";
}
public static void main(String[] args) {
Hello obj = new Hello();
System.out.println(obj.name);
}
}

Output:

Beginners

Types of Constructors
There are three types of constructors: Default, No-arg constructor and
Parameterized.
https://beginnersbook.com/2013/03/constructors-in-java/

Default constructor
If you do not implement any constructor in your class, Java compiler inserts
a default constructorinto your code on your behalf. This constructor is known as
default constructor. You would not find it in your source code(the java file) as it
would be inserted into the code during compilation and exists in .class file. This
process is shown in the diagram below:

If you implement any constructor then you no longer receive a default constructor
from Java compiler.
https://beginnersbook.com/2013/03/constructors-in-java/

no-arg constructor:
Constructor with no arguments is known as no-arg constructor. The signature
is same as default constructor, however body can have any code unlike default
constructor where the body of the constructor is empty.

Although you may see some people claim that that default and no-arg
constructor is same but in fact they are not, even if you write public Demo() { } in
your class Demo it cannot be called default constructor since you have written the
code of it.

Example: no-arg constructor

class Demo
{
public Demo()
{
System.out.println("This is a no argument constructor");
}
public static void main(String args[]) {
new Demo();
}
}
Output:
This is a no argument constructor
https://beginnersbook.com/2013/03/constructors-in-java/

Parameterized constructor
Constructor with arguments(or you can say parameters) is known
as Parameterized constructor.

Example: parameterized constructor

In this example we have a parameterized constructor with two

parameters id and name. While creating the objects obj1 and obj2 I have passed two
arguments so that this constructor gets invoked after creation of obj1 and obj2.

public class Employee {

int empId;
String empName;

//parameterized constructor with two parameters

Employee(int id, String name){
this.empId = id;
this.empName = name;
}
void info(){
System.out.println("Id: "+empId+" Name: "+empName);
}

public static void main(String args[]){

Employee obj1 = new Employee(10245,"Chaitanya");
Employee obj2 = new Employee(92232,"Negan");
obj1.info();
obj2.info();
}
}
Output:

Id: 10245 Name: Chaitanya

Id: 92232 Name: Negan
Example2: parameterized constructor

In this example, we have two constructors, a default constructor and a

parameterized constructor. When we do not pass any parameter while creating
https://beginnersbook.com/2013/03/constructors-in-java/

the object using new keyword then default constructor is invoked, however when
you pass a parameter then parameterized constructor that matches with the
passed parameters list gets invoked.

class Example2
{
private int var;
//default constructor
public Example2() // no argument
{
this.var = 10;
}
//parameterized constructor
public Example2(int num) // parameterized
{
this.var = num;
}
public int getValue()
{
return var;
}
public static void main(String args[])
{
Example2 obj = new Example2();
Example2 obj2 = new Example2(100);
System.out.println("var is: "+obj.getValue());
System.out.println("var is: "+obj2.getValue());
}
}
Output:

var is: 10
var is: 100

What if you implement only parameterized

constructor in class
class Example3
{
private int var;
public Example3(int num)
{
var=num;
}
public int getValue()
{
return var;
}
public static void main(String args[])
{
Example3 myobj = new Example3();
System.out.println("value of var is: "+myobj.getValue());
https://beginnersbook.com/2013/03/constructors-in-java/

}
}
Output: It will throw a compilation error. The reason is, the statement Example3
myobj = new Example3() is invoking a default constructor which we don’t have in our
program. when you don’t implement any constructor in your class, compiler
inserts the default constructor into your code, however when you implement any
constructor (in above example I have implemented parameterized constructor
with int parameter), then you don’t receive the default constructor by compiler
into your code.

If we remove the parameterized constructor from the above code then the
program would run fine, because then compiler would insert the default
constructor into your code.

Constructor Chaining
When A constructor calls another constructor of same class then this is called
constructor chaining. Read more about it here.
https://beginnersbook.com/2013/03/constructors-in-java/

Super()
Whenever a child class constructor gets invoked it implicitly invokes the
constructor of parent class. You can also say that the compiler inserts
a super(); statement at the beginning of child class constructor.

class MyParentClass {
MyParentClass(){
System.out.println("MyParentClass Constructor");
}
}
class MyChildClass extends MyParentClass{
MyChildClass() {
System.out.println("MyChildClass Constructor");
}
public static void main(String args[]) {
new MyChildClass();
}
}
Output:

MyParentClass Constructor
MyChildClass Constructor

Constructor Overloading
Constructor overloading is a concept of having more than one constructor with
different parameters list, in such a way so that each constructor performs a
different task.
https://beginnersbook.com/2013/03/constructors-in-java/

Constructor Overloading Example

Here we are creating two objects of class StudentData. One is with default
constructor and another one using parameterized constructor. Both the
constructors have different initialization code, similarly you can create any
number of constructors with different-2 initialization codes for different-2
purposes.

StudentData.java

class StudentData
{
private int stuID;
private String stuName;
private int stuAge;
StudentData()
{
//Default constructor
https://beginnersbook.com/2013/03/constructors-in-java/

stuID = 100;
stuName = "New Student";
stuAge = 18;
}
StudentData(int num1, String str, int num2)
{
//Parameterized constructor
stuID = num1;
stuName = str;
stuAge = num2;
}
//Getter and setter methods
public int getStuID() {
return stuID;
}
public void setStuID(int stuID) {
this.stuID = stuID;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public int getStuAge() {
return stuAge;
}
public void setStuAge(int stuAge) {
this.stuAge = stuAge;
}

public static void main(String args[])

{
//This object creation would call the default constructor
StudentData myobj = new StudentData();
System.out.println("Student Name is: "+myobj.getStuName());
System.out.println("Student Age is: "+myobj.getStuAge());
System.out.println("Student ID is: "+myobj.getStuID());

/*This object creation would call the parameterized

* constructor StudentData(int, String, int)*/
StudentData myobj2 = new StudentData(555, "Chaitanya", 25);
System.out.println("Student Name is: "+myobj2.getStuName());
System.out.println("Student Age is: "+myobj2.getStuAge());
System.out.println("Student ID is: "+myobj2.getStuID());
}
}
Output:

Student Name is: New Student

Student Age is: 18
Student ID is: 100
Student Name is: Chaitanya
Student Age is: 25
https://beginnersbook.com/2013/03/constructors-in-java/

Student ID is: 555

Constructor Override
a constructor cannot be overridden

Constructors are not normal methods and they cannot be "overridden".

A constructor is a special member function of class with the same name as that of class.

Java Copy Constructor

A copy constructor is used for copying the values of one object to another object.

class JavaExample{
String web;
JavaExample(String w){
web = w;
}

/* This is the Copy Constructor, it

* copies the values of one object
* to the another object (the object
* that invokes this constructor)
*/
JavaExample(JavaExample je){
web = je.web;
}
void disp(){
System.out.println("Website: "+web);
}

public static void main(String args[]){

JavaExample obj1 = new JavaExample("BeginnersBook");

/* Passing the object as an argument to the constructor

* This will invoke the copy constructor
*/
JavaExample obj2 = new JavaExample(obj1);
obj1.disp();
obj2.disp();
}
}
https://beginnersbook.com/2013/03/constructors-in-java/

Output:

Website: BeginnersBook
Website: BeginnersBook

Difference between Constructor and Method

I know I should have mentioned it at the beginning of this guide but I wanted to
cover everything in a flow. Hope you don’t mind :)

1. The purpose of constructor is to initialize the object of a class while the

purpose of a method is to perform a task by executing java code.
2. Constructors cannot be abstract, final, static and synchronized while
methods can be.
3. Constructors do not have return types while methods do.

4. The constructor is not inherited but you are still able to call it.

5. No a subclass cannot inherit the constructors of its superclass. 

6. Constructors are special function members of a class in that they are not

inherited by the subclass. 

7. Constructors are used to give a valid state for an object at creation

https://beginnersbook.com/2013/03/constructors-in-java/
https://beginnersbook.com/2013/03/constructors-in-java/