Constructor chaining in Java - Step-by-Step Execution

Concept Flow - Constructor chaining

Call Constructor A

↓

Constructor A calls Constructor B

↓

Constructor B executes

↓

Return to Constructor A

↓

Constructor A completes

↓

Object fully constructed

Constructor chaining means one constructor calls another constructor in the same class or parent class to reuse code and initialize the object step-by-step.

Execution Sample

Java

class Box {
  int width, height;
  Box() { this(10, 20); }
  Box(int w, int h) { width = w; height = h; }
}

This code shows a no-argument constructor calling another constructor with two arguments to set width and height.

Execution Table

Step	Constructor Called	Parameters	Action	State Change	Output
1	Box()	none	Calls Box(int w, int h) with (10, 20)	width=0, height=0 (initial)
2	Box(int w, int h)	10, 20	Sets width=10, height=20	width=10, height=20
3	Box()	none	Returns after Box(int, int) finishes	width=10, height=20
4	Box()	none	Constructor completes	width=10, height=20

💡 No more constructors to call; object construction finished with width=10 and height=20

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
width	0	0	10	10	10
height	0	0	20	20	20

Key Moments - 3 Insights

Why does the no-argument constructor call the two-argument constructor?

To avoid repeating code for setting width and height, the no-argument constructor reuses the two-argument constructor by calling it with default values (see execution_table step 1).

What happens if the constructor chaining is not done properly?

If a constructor does not call another properly, variables may remain uninitialized or default, causing incorrect object state (see variable_tracker showing initial zeros before step 2).

Can constructor chaining call constructors in parent classes?

Yes, using super() calls the parent class constructor. This example shows chaining within the same class using this().

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what are the values of width and height?

A width=20, height=10

B width=0, height=0

C width=10, height=20

D width and height are uninitialized

💡 Hint

Check the 'State Change' column at step 2 in execution_table

At which step does the Box() constructor finish execution?

A Step 2

B Step 4

C Step 3

D Step 1

💡 Hint

Look for 'Constructor completes' in the Action column of execution_table

If the Box() constructor did not call Box(int w, int h), what would be the final values of width and height?

A width=0, height=0

B width=10, height=20

C width and height would be random

D width=20, height=10

💡 Hint

Refer to variable_tracker start values before any constructor runs

Concept Snapshot

Constructor chaining in Java:
- One constructor calls another using this() or super()
- Helps reuse code and set default values
- Called constructors run first, then return
- Ensures object fields are properly initialized
- Avoids code duplication in constructors

Full Transcript

Constructor chaining is when one constructor calls another constructor in the same class or parent class. This helps reuse code and initialize object fields step-by-step. For example, a no-argument constructor can call a two-argument constructor with default values. The called constructor runs first, sets the fields, then returns control to the original constructor. This ensures the object is fully initialized without repeating code. If chaining is missing, fields may remain at default values. Constructor chaining uses this() for same-class calls and super() for parent-class calls.

Practice

1. What is the main purpose of constructor chaining in Java?

easy

A. To allow one constructor to call another constructor in the same class

B. To inherit constructors from a parent class automatically

C. To create multiple objects with the same constructor

D. To override constructors with different names

Solution

1. Step 1: Understand constructor chaining concept

   Constructor chaining means one constructor calls another constructor in the same class to reuse code.

2. Step 2: Identify the correct purpose

   To allow one constructor to call another constructor in the same class correctly describes this behavior using this(...) to call another constructor.

3. Final Answer:

   To allow one constructor to call another constructor in the same class -> Option A

4. Quick Check:

   Constructor chaining = calling another constructor [OK]

Hint: Constructor chaining uses this(...) to call another constructor [OK]

Common Mistakes:

• Confusing constructor chaining with inheritance
• Thinking constructors can have different names
• Believing constructor chaining creates multiple objects

2. Which of the following is the correct syntax to chain constructors in Java?

easy

A. this.call(); // calls another method

B. super(); // calls constructor of same class

C. this(); // must be the first statement in constructor

D. constructor(); // calls constructor by name

Solution

1. Step 1: Recall syntax for constructor chaining

   Constructor chaining uses this(...) as the first statement inside a constructor.

2. Step 2: Identify correct option

   this(); // must be the first statement in constructor shows this(); which is the correct syntax to call another constructor in the same class.

3. Final Answer:

   this(); // must be the first statement in constructor -> Option C

4. Quick Check:

   Constructor chaining syntax = this() first [OK]

Hint: Use this() as first line to chain constructors [OK]

Common Mistakes:

• Using super() to call same class constructor
• Calling constructor by its name directly
• Placing this() after other statements

3. What will be the output of the following Java code?

class Test {
  Test() {
    this(5);
    System.out.print("A");
  }
  Test(int x) {
    System.out.print("B");
  }
  public static void main(String[] args) {
    new Test();
  }
}

medium

A. AB

B. BA

C. A

D. B

Solution

1. Step 1: Trace constructor calls

   Creating new Test() calls the no-arg constructor, which calls Test(int x) first (prints "B"), then prints "A".

2. Step 2: Determine output order

   Since Test(int x) prints "B" first, then control returns to no-arg constructor which prints "A", output is "BA".

3. Final Answer:

   BA -> Option B

4. Quick Check:

   Constructor chaining prints B then A [OK]

Hint: Constructor chaining prints inner constructor output first [OK]

Common Mistakes:

• Assuming outer constructor prints before inner
• Confusing order of constructor calls
• Ignoring that this() must be first line

4. Identify the error in the following Java code related to constructor chaining:

class Sample {
  Sample() {
    System.out.println("Hello");
    this(10);
  }
  Sample(int x) {
    System.out.println(x);
  }
}

medium

A. Constructor chaining call this(10) must be the first statement

B. Constructor name must match class name

C. Cannot overload constructors with different parameters

D. Missing return type in constructors

Solution

1. Step 1: Check constructor chaining rules

   In Java, the call to another constructor using this(...) must be the first statement in the constructor.

2. Step 2: Identify the error

   Here, System.out.println("Hello") comes before this(10);, which violates the rule.

3. Final Answer:

   Constructor chaining call this(10) must be the first statement -> Option A

4. Quick Check:

   this() must be first line in constructor [OK]

Hint: this() call must be first statement in constructor [OK]

Common Mistakes:

• Placing code before this() call
• Confusing constructor overloading with chaining
• Thinking constructors need return types

5. Given the class below, what will be the output when new Box(); is executed?

class Box {
  Box() {
    this(3, 4);
    System.out.print("X");
  }
  Box(int w, int h) {
    this(w, h, 5);
    System.out.print("Y");
  }
  Box(int w, int h, int d) {
    System.out.print("Z");
  }
}

hard

A. ZXY

B. ZY

C. XYZ

D. ZYX

Solution

1. Step 1: Trace constructor chaining calls

   Calling new Box() calls no-arg constructor, which calls Box(int w, int h), which calls Box(int w, int h, int d).

2. Step 2: Track printed characters in order

   The deepest constructor prints "Z" first, then returns to middle constructor which prints "Y", then returns to no-arg constructor which prints "X".

3. Final Answer:

   ZYX -> Option D

4. Quick Check:

   Chained constructors print Z then Y then X [OK]

Hint: Deepest constructor prints first, then unwind chain [OK]

Common Mistakes:

• Assuming outer constructor prints first
• Ignoring chaining order
• Mixing up print order in nested calls