Constructors in Java | Constructor Chaining, Overloading & this

This chapter explores the core mechanics of object initialization in Java. It covers how instance variables receive default values, why local variables behave differently, and how constructors streamline object creation. Additionally, it examines advanced concepts such as constructor overloading, the execution of the this keyword, and the implementation of constructor chaining to write clean, maintainable code.

1. The Problem: Manual Object Initialization & Default Values

When we design a class in Java, we define fields to represent the characteristics of a real-world entity. However, if we instantiate an object and attempt to read its fields before explicitly assigning any values, Java does not throw a compilation error. Instead, it provides default values.

Consider the following naive implementation of a Student class:

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    void markAttendance() {
        System.out.println("Attendance marked for student: " + name);
    }
}

If we instantiate this class in our main method and immediately print its fields without assigning values:

public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student();
        
        System.out.println("Name: " + s1.name);
        System.out.println("Age: " + s1.age);
        System.out.println("Roll Number: " + s1.rollNumber);
        System.out.println("College: " + s1.college);
    }
}

Console Output

Name: null
Age: 0
Roll Number: 0
College: null

These outputs (null and 0) are called default values. Java automatically assigns these values to fields when an object is allocated in memory, ensuring that the program does not read uninitialized garbage data.

2. Instance Variables vs. Local Variables

To understand why default values exist, we must distinguish between Instance Variables and Local Variables.

The Local Variable Initialization Error

If we declare a local variable inside a method and attempt to print it without initialization, the compiler halts execution:

public class Demo {
    public static void main(String[] args) {
        int x;
        // System.out.println(x); // COMPILE-TIME ERROR: The local variable x may not have been initialized
    }
}

3. Memory Allocation & The Optimization Rationale

Why does Java provide default values for instance variables in the Heap but forces manual initialization for local variables in the Stack?

The Optimization Rationale

1. Lifetime and Scope: Local variables exist only as long as their containing method is executing. Because their lifecycle is incredibly short, Java optimizes performance by skipping automatic initialization. It places the responsibility on the developer to initialize them before use.
2. Heap Safety: Objects stored in the Heap are accessed dynamically across different parts of an application and persist much longer. To prevent null pointer crashes or garbage-value calculations during runtime, Java guarantees that every slot of allocated Heap memory is initialized to a predictable default state.

Default Values by Data Type

Note: String is a non-primitive reference type (it is a class in Java). Therefore, its default value is always null, not an empty string "".

4. Introduction to Constructors: Rules & Syntax

Manually assigning values to an object's fields after creation is tedious and error-prone:

Student s1 = new Student();
s1.name = "Aditya";
s1.age = 28;
s1.rollNumber = 1001;
s1.college = "IIT Guwahati";

If a class has dozens of fields, it is easy to forget to initialize one, leaving it with a default value. To solve this, Java uses Constructors. A constructor is a special block of code designed to initialize an object immediately upon creation.

Rules of Constructors

1. Same Name as Class: The constructor's name must match the class name exactly.
2. No Return Type: It must not declare any return type—not even void.
3. Automatic Invocation: It is called automatically when the new keyword allocates memory for a new object.
4. Object Initialization: Its primary purpose is to initialize the instance variables of the newly created object.
5. Overloadable: Like regular methods, constructors can be overloaded by changing their parameter lists.

Basic Constructor Syntax

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    // Custom No-Argument Constructor
    Student() {
        name = "Aditya";
        age = 28;
        rollNumber = 1001;
        college = "IIT Guwahati";
    }
}

When we execute Student s1 = new Student();, the constructor runs automatically, initializing the object with these predefined values instead of null and 0.

5. Default vs. Parameterized Constructors

Java constructors fall into three main categories:

A. The Implicit Default Constructor

If you do not write any constructor in your class, the Java compiler automatically inserts an empty, no-argument constructor during compilation.

// What you write:
class Student {
    String name;
}

// What the compiler generates behind the scenes:
class Student {
    String name;

    Student() {
        super(); // Calls the parent Object class constructor
    }
}

This compiler-generated constructor is called the Implicit Default Constructor. It leaves all instance variables at their respective default values.

B. Parameterized Constructors

To make object creation dynamic, we can pass arguments to our constructor. This allows us to initialize different objects with unique values at the moment of instantiation.

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    // Parameterized Constructor
    Student(String n, int a, int r, String c) {
        name = n;
        age = a;
        rollNumber = r;
        college = c;
    }
}

Now, we can instantiate objects with custom values in a single line:

Student s1 = new Student("Rohit", 28, 1002, "IIT Guwahati");

6. Constructor Overloading

Constructor Overloading is the practice of defining multiple constructors within the same class, each having a unique parameter list (different number, order, or types of parameters).

Crucial Rule: If you define any custom constructor (parameterized or no-arg), Java will not generate the implicit default constructor. If you still want to instantiate objects without arguments, you must explicitly write a no-argument constructor.

Here is an example of constructor overloading:

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    // Constructor 1: No-Argument Constructor
    Student() {
        this.name = "Unknown";
        this.age = 0;
        this.rollNumber = 0;
        this.college = "Unknown";
    }

    // Constructor 2: Parameterized Constructor (Name only)
    Student(String name) {
        this.name = name;
        this.age = 0;
        this.rollNumber = 0;
        this.college = "Unknown";
    }

    // Constructor 3: Fully Parameterized Constructor
    Student(String name, int age, int rollNumber, String college) {
        this.name = name;
        this.age = age;
        this.rollNumber = rollNumber;
        this.college = college;
    }
}

7. The this Keyword: Resolving Variable Shadowing

In our parameterized constructor example, we used different variable names for parameters (e.g., String n, int a) to avoid clashing with the instance variables (name, age).

However, using arbitrary names like n or a reduces code readability. It is better to use identical names for both parameters and instance variables. This introduces a challenge called Variable Shadowing.

The Shadowing Problem

class Student {
    String name; // Instance Variable

    Student(String name) { // Parameter (Local Variable)
        name = name; // Confusing! Assigns the parameter to itself; instance variable remains null.
    }
}

In the code above, the compiler prioritizes the local parameter name over the instance variable name. The statement name = name simply reassigns the parameter value to itself, leaving the instance variable uninitialized (null).

The Solution: this

The this keyword in Java is a reference variable that points directly to the current object executing the constructor or method.

class Student {
    String name; // Instance Variable

    Student(String name) {
        this.name = name; // "this.name" refers to the instance variable; "name" refers to the parameter.
    }
}

Using this.name tells the compiler to bypass local shadowing and assign the parameter value directly to the object's field in Heap memory.

8. Constructor Chaining: The Naive vs. Decoupled Approach

When overloading constructors, we often write repetitive initialization code:

// Naive, Repetitive Approach
Student() {
    this.name = "Unknown";
    this.age = 0;
    this.rollNumber = 0;
    this.college = "Unknown";
}

Student(String name) {
    this.name = name;
    this.age = 0;
    this.rollNumber = 0;
    this.college = "Unknown";
}

This violates the DRY (Don't Repeat Yourself) principle. If we need to change how a default value is initialized, we would have to update it across multiple constructors.

The Decoupled Solution: Constructor Chaining

Constructor Chaining is the process of calling one constructor from another within the same class. We do this using the this() syntax, passing the appropriate arguments.

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    // No-Argument Constructor chains to the fully parameterized constructor
    Student() {
        this("Unknown", 0, 0, "Unknown"); 
    }

    // Single-parameter constructor chains to the fully parameterized constructor
    Student(String name) {
        this(name, 0, 0, "Unknown");
    }

    // Fully Parameterized Constructor (The single point of initialization)
    Student(String name, int age, int rollNumber, String college) {
        this.name = name;
        this.age = age;
        this.rollNumber = rollNumber;
        this.college = college;
    }
}

9. Progressive Constructor Chaining (Step-by-Step Evolution)

Instead of having every constructor call the largest constructor directly, we can chain them progressively. In this pattern, each constructor calls the next largest one, adding its own default values along the way.

class Student {
    String name;
    int age;
    int rollNumber;
    String college;

    // 1st Constructor (No-Arg) -> Calls 2nd Constructor
    Student() {
        this("Unknown");
        System.out.println("I am in first constructor");
    }

    // 2nd Constructor (1-Arg) -> Calls 3rd Constructor
    Student(String name) {
        this(name, 0);
        System.out.println("I am in second constructor");
    }

    // 3rd Constructor (2-Arg) -> Calls 4th Constructor
    Student(String name, int age) {
        this(name, age, 0);
        System.out.println("I am in third constructor");
    }

    // 4th Constructor (3-Arg) -> Calls 5th Constructor
    Student(String name, int age, int rollNumber) {
        this(name, age, rollNumber, "Unknown");
        System.out.println("I am in fourth constructor");
    }

    // 5th Constructor (4-Arg) -> Performs actual assignment
    Student(String name, int age, int rollNumber, String college) {
        this.name = name;
        this.age = age;
        this.rollNumber = rollNumber;
        this.college = college;
        System.out.println("I am in fifth constructor");
    }
}

The Golden Rule of this()

Important: Any call to this() must be the very first statement in your constructor. If you place any code (such as a print statement) before this(), the compiler will throw an error.

JAVA

Copy

Student() {
    System.out.println("Hello"); // COMPILE-TIME ERROR!
    this("Unknown"); 
}

10. Execution Flow Walkthrough of Chained Constructors

Let's trace what happens in memory and on the console when we instantiate an object using the no-argument constructor:

Student s1 = new Student();

Execution Flow Diagram

Console Output

I am in fifth constructor
I am in fourth constructor
I am in third constructor
I am in second constructor
I am in first constructor

Because each constructor must call this() before executing its own code, the actual initialization work happens in the final, fully parameterized constructor first. The call stack then unwinds, executing the remaining print statements in reverse order.

11. Critical Interview Questions & Edge Cases

Q1. Can we call a constructor manually like a regular method?

No. You cannot call a constructor on an existing object like a normal method (e.g., s1.Student()).

Constructors can only be invoked in two ways:

1. Using the new keyword during object creation (new Student()).
2. Using the this() or super() keyword inside another constructor.

Q2. What happens if Heap memory runs out of space during object allocation?

The new keyword allocates memory dynamically on the Heap at runtime. If your application creates too many objects and the Heap runs out of space, Java will throw a runtime error:

java.lang.OutOfMemoryError: Java heap space

This is a critical runtime error, not a compile-time error, because memory availability can only be determined while the program is running.

Summary and Key Takeaways

• Instance variables reside in Heap memory and are automatically initialized to default values (0, 0.0, false, or null).
• Local variables reside in Stack memory and do not receive default values. Reading an uninitialized local variable causes a compile-time error.
• Constructors are special methods with no return type (not even void) that share the exact name of their class. They run automatically during object creation.
• If you do not write any constructor, Java inserts an implicit default constructor. Once you write any custom constructor, this default constructor is no longer provided.
• Constructor Overloading allows a class to have multiple constructors with different parameter lists.
• The this keyword refers to the current object instance. It is commonly used to resolve variable shadowing when parameter names match instance variable names.
• Constructor Chaining uses this() to call one constructor from another within the same class, reducing code duplication.
• Any call to this() must be the first statement in the constructor body.
• Constructors cannot be called manually like regular methods; they are only invoked via the new keyword or through constructor chaining.