Constructor execution flow in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a constructor in Java?

A constructor is a special method in Java used to create and initialize objects. It has the same name as the class and no return type.

beginner

What happens first when a Java object is created?

The superclass constructor is called first before the subclass constructor runs. This ensures the parent part of the object is initialized first.

intermediate

How does Java decide which constructor to call in a class hierarchy?

Java calls constructors starting from the top superclass down to the subclass. Each constructor calls its superclass constructor using super(), either explicitly or implicitly.

intermediate

What is the role of the super() call in constructor execution?

super() calls the parent class constructor. If not written explicitly, Java inserts super() automatically as the first line in a constructor.

advanced

In what order are instance variables initialized during constructor execution?

Instance variables are initialized first in the order they appear, then the constructor body runs. This happens for each class from superclass to subclass.

When creating an object, which constructor runs first?

A Random constructor

B Subclass constructor

C Superclass constructor

D No constructor runs automatically

The superclass constructor runs first to initialize the parent part of the object.

What does Java insert automatically if a constructor does not call super() explicitly?

A super() call as the first line

B this() call as the first line

C No call is inserted

D A return statement

Java inserts super() automatically as the first statement to call the parent constructor.

Which of these is true about instance variable initialization during constructor execution?

A Variables initialize randomly

B Variables initialize before constructor body runs

C Variables never initialize automatically

D Variables initialize after constructor body runs

Instance variables are initialized first, then the constructor body executes.

If a subclass constructor calls super(), what does it do?

A Calls the superclass constructor

B Calls itself recursively

C Calls a method named super

D Does nothing

super() calls the constructor of the immediate parent class.

What is the order of constructor execution in a class hierarchy?

A Random order

B Subclass to superclass

C Only subclass constructor runs

D Top superclass to subclass

Constructors run from the top superclass down to the subclass.

Explain the flow of constructor execution when creating an object in Java.

Think about how Java builds an object from parent to child.

Describe what happens if you do not explicitly call super() in a subclass constructor.

Remember Java's default behavior for constructor chaining.

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