Constructor in Java: Examples, Types & Constructor Overloading

Constructors are the gateway to Object-Oriented Programming in Java.

In this tutorial, we will break down how Java creates and initializes objects, why constructors are overloaded, and explore practical code examples to solidify your understanding.

What is a Constructor in Java?

Watch: Java Constructor & Constructor Overloading

How Object Creation and Constructors Work in Java

When an object is created with new, Java first creates and initializes the object’s instance fields with default values, and then the constructor executes to perform the initialization defined by the class:

1. Object Creation & Default Initialization: Java creates an instance and temporarily assigns default primitive values to all fields (0 for numbers, false for booleans, null for objects).
2. Constructor Execution: The constructor body executes and performs the initialization specified by your code. Any fields not explicitly initialized retain their default values.

Types of Constructors in Java

Java constructors are commonly discussed in terms of three types or categories:

1. Default Constructor: A hidden, invisible constructor automatically provided by the Java compiler only if you write zero constructors in your class. It takes no parameters and has an empty body.
2. No-Argument Constructor: An explicit, programmer-written constructor that takes no parameters.
3. Parameterized Constructor: A constructor that takes one or more arguments, allowing you to pass dynamic values to initialize the object.

class Product {
    int id;
    String title;
    double price;

    // No-Argument Constructor
    Product() {
        System.out.println("No-argument constructor called");
    }

    // Parameterized Constructor
    Product(int id, String title, double price) {
        this.id = id;
        this.title = title;
        this.price = price;
    }
}

In the parameterized constructor above, this.id refers to the class instance variable, while id refers to the local parameter. You can create a Product object using either constructor, depending on whether you have values available at the time of creation.

Constructor Overloading in Java

Constructor overloading means creating multiple constructors in the same class with different parameter lists. This allows you to create objects in flexible ways depending on the data you currently have available, similar to standard method overloading.

class Product {
    int id;
    String title;
    double price;

    // 1. No parameters
    Product() {
        title = "Unknown";
    }

    // 2. One parameter
    Product(String title) {
        this.title = title;
    }

    // 3. Three parameters
    Product(int id, String title, double price) {
        this.id = id;
        this.title = title;
        this.price = price;
    }
}

Because the parameter signatures are different (none, one String, or an int, String, and double), the compiler knows exactly which constructor to invoke when you use the new keyword.

Constructor Chaining Using this()

To avoid writing duplicate initialization code across overloaded constructors, you can invoke one constructor from another within the same class using this().

class Product {
    int id;
    String title;
    double price;

    // Invokes the three-parameter constructor
    Product() {
        this(0, "Unknown", 0.0); 
    }

    Product(int id, String title, double price) {
        this.id = id;
        this.title = title;
        this.price = price;
    }
}

Crucial Rule: The this() statement must be the very first line of code inside the constructor body, otherwise the code will not compile.

Constructor vs Method in Java

Common Interview Traps & Edge Cases

• Can a constructor be final, static, or abstract?
  No. Constructors cannot be static because they belong to an instance, not the class. They cannot be overridden, so marking them final or abstract is syntactically illegal and results in a compilation error.
• What is a Copy Constructor?
  Unlike C++, Java does not provide a special built-in copy-constructor mechanism. However, you can define a constructor that accepts an object of the same class and copies selected fields from it:
  Product(Product p) { this.id = p.id; this.title = p.title; this.price = p.price; }

Frequently Asked Questions

Need more help mastering object-oriented programming concepts? Connect with an online Java tutor for private 1-on-1 training or customized technical coaching.