Constructor

A Constructor is a block of code that gets executed when an object is instantiated using new keyword. Every class that we create will have a constructor implicitly provided by the compiler. We can also write our own constructor and use it to initialize the object.

We define the constructor with the name of the class itself.

public name-of-the-class() {
	// Code
}

Since constructor is the first thing that gets executed when we create an object, it is the best place to initialize the object.

Constructor can have arguments, but it is not a function, so it will not have a return statement.

package com.techstackjournal.app.types;

public class Employee {

	private String id;
	private String name;
	private double salary;

	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]";
	}

}

In this class, we’ve one Employee constructor which takes multiple variables as constructor arguments, which are being used for initializing the instance variables.

Here, id, name and salary are constructor arguments or just variables. However, this.id, this.name and this.salary are the instance variables.

Keyword this always refers to the current object.

Keyword this is not mandatory to refer the instance variables, however, when the argument variable and instance variable both have the same name, we can use this keyword to differentiate both of them. But it is a general practice to use this keyword when we are referring to the instance variable.

Let’s create a main program to create an instance of this Employee class using constructor.

package com.techstackjournal.app.main;

import com.techstackjournal.app.types.Employee;

public class Application {

	public static void main(String[] args) {

		Employee emp = new Employee("E001", "John Doe", 8000);

		System.out.println(emp);

	}

}

In this main program, we are passing the employee details while creating an instance of Employee class.

We need to make sure the order of the arguments is matching with the definition of the constructor. Since Employee constructor accepts first two arguments as String and the last argument as double, we need to pass the arguments in similar sequence. However, if you pass name first and employee id next, Java cannot warn you anything as for it both of them are Strings.

When there were no constructors in the class, we could create an instance of the class using an empty constructor. But if a class contains at least one constructor with arguments but not an empty constructor, you will not be able to instantiate the class using empty constructor call now.

Employee emp = new Employee();

Above line of code will throw a compilation error as we do not have empty constructor in the class.

Constructor Overloading

Writing more than one constructor in a class with unique set of arguments is called as Constructor overloading. When you have more than one constructor,

package com.techstackjournal.app.types;

public class Employee {

	private String id;
	private String name;
	private double salary;

	public Employee() {
		System.out.println("Constructing with 1 argument...");
		this.salary = 8000;
	}

	public Employee(String id, String name) {
		System.out.println("Constructing with 2 arguments...");
		this.id = id;
		this.name = name;
	}

	public Employee(String id, String name, double salary) {
		System.out.println("Constructing with 3 arguments...");
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]";
	}

}

In the above class, there are 3 constructors, a constructor without arguments, a constructor with 2 arguments and a constructor with 3 arguments.

Let’s create a main program to consume this Employee class.

package com.techstackjournal.app.main;

import com.techstackjournal.app.types.Employee;

public class Application {

	public static void main(String[] args) {

		Employee emp1 = new Employee();
		Employee emp2 = new Employee("E001", "John Doe");
		Employee emp3 = new Employee("E002", "John Doe", 9000);

		System.out.println("Employee 1: " + emp1);
		System.out.println("Employee 2: " + emp2);
		System.out.println("Employee 3: " + emp3);

	}

}

Constructing with 1 argument...
Constructing with 2 arguments...
Constructing with 3 arguments...
Employee 1: Employee [id=null, name=null, salary=8000.0]
Employee 2: Employee [id=E001, name=John Doe, salary=0.0]
Employee 3: Employee [id=E002, name=John Doe, salary=9000.0]

As you can see in the output, creating an object without any arguments will call no-arg constructor, creating an object with 2 arguments calls 2-arg constructor and so on.