Constructor execution flow in Java - Step-by-Step Execution

Concept Flow - Constructor execution flow

Create Object

↓

Call Constructor

↓

Initialize Instance Variables

↓

Execute Constructor Body

↓

Return Object Reference

↓

Object Ready

When creating an object, Java calls the constructor which runs its code to initialize the object before returning it.

Execution Sample

Java

class Box {
  int width;
  Box(int w) {
    width = w;
  }
}
Box b = new Box(5);

This code creates a Box object with width set to 5 by running the constructor.

Execution Table

Step	Action	Variable/Field	Value	Notes
1	Call constructor Box(5)	w	5	Parameter w receives 5
2	Assign width = w	width	5	Instance variable width set to 5
3	Constructor ends	-	-	Object initialization complete
4	Object reference assigned	b	Box@<address>	Variable b holds new object reference

💡 Constructor finishes, object is fully initialized and ready to use

Variable Tracker

Variable/Field	Start	After Step 1	After Step 2	Final
w	-	5	5	5
width	0 (default)	0 (default)	5	5
b	null	null	null	Box@<address>

Key Moments - 3 Insights

Why does the instance variable 'width' have value 0 before assignment?

Java initializes instance variables to default values (0 for int) before the constructor runs, as shown in variable_tracker after start.

What happens if we do not assign 'width = w' inside the constructor?

The instance variable 'width' remains at its default value 0, so the object won't have the intended width, as seen in step 2 of execution_table.

When is the object reference 'b' assigned the new object?

After the constructor finishes (step 3), the new object reference is assigned to 'b' (step 4), so 'b' points to the fully initialized object.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'width' after step 2?

A null

B 0

C 5

D undefined

💡 Hint

Check the 'width' column in execution_table row for step 2

At which step is the constructor body executed?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column describing assignment inside constructor

If we remove 'width = w;' from the constructor, what changes in variable_tracker?

A 'w' becomes 0

B 'width' stays 0 after all steps

C 'b' becomes null

D No change

💡 Hint

Refer to variable_tracker row for 'width' and how assignment affects it

Concept Snapshot

Constructor execution flow in Java:
- Object creation calls constructor
- Constructor parameters receive arguments
- Instance variables initialized to defaults before constructor
- Constructor body runs, assigns values
- Object reference assigned after constructor ends

Full Transcript

When you create an object in Java, the constructor runs first. The constructor receives any parameters you pass. Before the constructor runs, Java sets instance variables to default values like 0 for numbers. Then the constructor code runs and assigns values to these variables. After the constructor finishes, the new object reference is assigned to your variable. This process ensures your object is ready to use with all fields properly set.

Practice

1. In Java, when you create an object of a child class, which constructor runs first?

easy

A. The parent class constructor

B. The child class constructor

C. Both constructors run simultaneously

D. No constructor runs automatically

Solution

1. Step 1: Understand constructor call order

   In Java, when creating an object, the parent class constructor runs before the child class constructor.

2. Step 2: Reason about object creation

   This ensures the parent part of the object is set up before the child adds its own setup.

3. Final Answer:

   The parent class constructor -> Option A

4. Quick Check:

   Parent constructor runs first [OK]

Hint: Parent constructor always runs before child constructor [OK]

Common Mistakes:

• Thinking child constructor runs first
• Believing constructors run simultaneously
• Assuming constructors don't run automatically

2. Which of the following is the correct way to call a parent class constructor from a child class in Java?

easy

A. this();

B. parent();

C. super();

D. base();

Solution

1. Step 1: Recall Java syntax for parent constructor call

   Java uses the keyword super() to call the parent class constructor explicitly.

2. Step 2: Check other options

   parent(), this(), and base() are not valid Java syntax for this purpose.

3. Final Answer:

   super(); -> Option C

4. Quick Check:

   Use super() to call parent constructor [OK]

Hint: Use super() to call parent constructor explicitly [OK]

Common Mistakes:

• Using this() instead of super()
• Trying parent() or base() which don't exist
• Omitting the call when needed

3. What is the output of the following Java code?

class Parent {
    Parent() {
        System.out.print("P");
    }
}
class Child extends Parent {
    Child() {
        System.out.print("C");
    }
}
public class Test {
    public static void main(String[] args) {
        new Child();
    }
}

medium

A. CP

B. PC

C. C

D. P

Solution

1. Step 1: Identify constructor calls

   Creating new Child() calls the Child constructor, which implicitly calls the Parent constructor first.

2. Step 2: Trace output order

   Parent constructor prints "P" first, then Child constructor prints "C".

3. Final Answer:

   PC -> Option B

4. Quick Check:

   Parent prints P, then Child prints C [OK]

Hint: Parent constructor output appears before child output [OK]

Common Mistakes:

• Assuming child prints before parent
• Ignoring implicit super() call
• Expecting only one letter output

4. Consider this Java code snippet:

class A {
    A() {
        System.out.print("A");
    }
}
class B extends A {
    B() {
        System.out.print("B");
    }
}
class C extends B {
    C() {
        System.out.print("C");
    }
}
public class Main {
    public static void main(String[] args) {
        new C();
    }
}

What is the output, and if there is an error, how to fix it?

medium

A. ABC

B. Error: No default constructor in A

C. Error: Constructor call missing in B

D. BAC

Solution

1. Step 1: Check constructor chaining

   Each class has a default constructor that implicitly calls its parent constructor.

2. Step 2: Trace constructor calls

   Creating new C() calls C(), which calls B(), which calls A(), printing "A", then "B", then "C".

3. Final Answer:

   ABC -> Option A

4. Quick Check:

   Constructors chain up and print in order A-B-C [OK]

Hint: Default constructors chain automatically if no args [OK]

Common Mistakes:

• Expecting error without explicit constructors
• Thinking constructors don't chain automatically
• Mixing output order

5. Given these classes:

class Vehicle {
    Vehicle() {
        System.out.print("V");
    }
}
class Car extends Vehicle {
    Car() {
        super();
        System.out.print("C");
    }
}
class SportsCar extends Car {
    SportsCar() {
        System.out.print("S");
    }
}
public class Demo {
    public static void main(String[] args) {
        new SportsCar();
    }
}

What is the output, and why does it appear in that order?

hard

A. CSV

B. VSC

C. SVC

D. VCS

Solution

1. Step 1: Analyze constructor calls

   Creating new SportsCar() calls SportsCar(), which implicitly calls Car(), which calls Vehicle() via super().

2. Step 2: Trace output sequence

   Vehicle constructor prints "V", then Car prints "C", then SportsCar prints "S".

3. Final Answer:

   VCS -> Option D

4. Quick Check:

   Parent to child constructor output order is V-C-S [OK]

Hint: Parent constructors run before child, print in that order [OK]

Common Mistakes:

• Assuming SportsCar calls super() explicitly
• Mixing output order
• Forgetting implicit super() call in SportsCar