Java Constructors

Constructor in java is used to create the instance of the class. Constructors are almost similar to methods except for two things - its name is the same as the class name and it has no return type.

Whenever we use new keyword to create an instance of a class, the constructor is invoked and the object of the class is returned. Since constructor can only return the object to class, it’s implicitly done by java runtime and we are not supposed to add a return type to it. If we add a return type to a constructor, then it will become a method of the class. This is the way java runtime distinguish between a normal method and a constructor


    public Employee() {
        System.out.println("Employee Constructor");
    }
    
    
    public Employee Employee() {
        System.out.println("Employee Method");
        return new Employee();
    }

Here the first one is a constructor, notice that there is no return type and no return statement. The second one is a normal method where we are again calling the first constructor to get Employee instance and return it. It’s recommended to not have method name same as the class name because it creates confusion.

Types of Constructor in Java

There are three types of constructor in java.

    1. Default Constructor
    2. No-Args constructor
    3. Parameterized constructor

1. Default Constructor

It’s not required to always provide a constructor implementation in the class code. If we don’t provide a constructor, then java provides default constructor implementation for us to use. Let’s look at a simple program where default constructor is being used since we will not explicitly define a constructor.


    public class Data {

        public static void main(String[] args) {
            Data d = new Data();
        }
    }
  1. 1. Default constructor only role is to initialize the object and return it to the calling code.
  2. 2. Default constructor is always without argument and provided by java compiler only when there is no existing constructor defined.
  3. 3. Most of the time we are fine with default constructor itself as other properties can be accessed and initialized through getter setter methods.
2. No-Args constructor

Constructor without any argument is called a no-args constructor. It’s like overriding the default constructor and used to do some pre-initialization stuff such as checking resources, network connections, logging, etc.

Example:

    public class Data {
        //no-args constructor
        public Data() {
            System.out.println("No-Args Constructor");
        }
        public static void main(String[] args) {
            Data d = new Data();
        }
    }
3. Parameterized constructor

Constructor with arguments is called parameterized constructor.

Example:

    public class Data {

        private String name;
    
        public Data(String n) {
            System.out.println("Parameterized Constructor");
            this.name = n;
        }
    
        public String getName() {
            return name;
        }
    
        public static void main(String[] args) {
            Data d = new Data("Java");
            System.out.println(d.getName());
        }
    
    }
Constructor Overloading in Java

When we have more than one constructors, then it’s constructor overloading in java. Let’s look at an example of constructor overloading in java program.

Example:

    public class Data {

        private String name;
        private int id;
    
        //no-args constructor
        public Data() {
            this.name = "Default Name";
        }
        //one parameter constructor
        public Data(String n) {
            this.name = n;
        }
        //two parameter constructor
        public Data(String n, int i) {
            this.name = n;
            this.id = i;
        }
    
        public String getName() {
            return name;
        }
    
        public int getId() {
            return id;
        }
    
        @Override
        public String toString() {
            return "ID="+id+", Name="+name;
        }
        public static void main(String[] args) {
            Data d = new Data();
            System.out.println(d);
            
            d = new Data("Java");
            System.out.println(d);
            
            d = new Data("Pankaj", 25);
            System.out.println(d);
            
        }
    
    }
Private Constructor in Java

Note that we can’t use abstract, final, static and synchronized keywords with constructors. However we can use access modifiers to control the instantiation of class object. Using public and default access is still fine, but what is the use of making a constructor private? In that case any other class won’t be able to create the instance of the class. Well, a constructor is made private in case we want to implement singleton design pattern. Since java automatically provides default constructor, we have to explicitly create a constructor and keep it private.

Example:

public class Data {
    //private constructor
    private Data() {
        System.out.println("private Constructor");
    }
    public static void main(String[] args) {
        Data d = new Data();
    }
}