Constructor chaining in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of constructor chaining with this()

What is the output of the following Java program that uses constructor chaining?

Java

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

A BA

B AB

C A

D B

💡 Hint

Remember that this() calls another constructor before executing the current one.

The no-argument constructor calls the constructor with int parameter first, printing 'B'. Then it prints 'A'. So the output is 'BA'.

❓ Predict Output

intermediate

Constructor chaining with super() and this()

What will be printed when the following Java code runs?

Java

class Parent {
    Parent() {
        System.out.print("P");
    }
}
class Child extends Parent {
    Child() {
        this(10);
        System.out.print("C");
    }
    Child(int x) {
        super();
        System.out.print("X");
    }
}
public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

A XP

B PCX

C PC

D PXC

💡 Hint

Check the order of constructor calls: this() calls another constructor, which calls super().

Child() calls this(10), which calls super() printing 'P', then prints 'X'. After returning, Child() prints 'C'. So output is 'PXC'.

🔧 Debug

advanced

Identify the compilation error in constructor chaining

Which option correctly identifies the compilation error in this Java class?

Java

public class Demo {
    Demo() {
        this(5);
        System.out.println("Hello");
    }
    Demo(int x) {
        this();
        System.out.println(x);
    }
}

A Cannot call this() and super() in the same constructor

B Missing return statement in constructor

C Recursive constructor call causing a compile-time error

D No default constructor defined

💡 Hint

Check if constructors call each other in a loop.

The constructor Demo() calls Demo(int), which calls Demo() again, causing infinite recursion in constructor calls. This is a compile-time error.

📝 Syntax

advanced

Which constructor chaining syntax is invalid?

Which of the following constructor chaining statements will cause a compilation error in Java?

A public MyClass() { super(); this(10); }

B public MyClass() { this(10); }

C public MyClass(int x) { super(); }

D public MyClass(int x) { this(); }

💡 Hint

Remember that this() or super() must be the first statement in a constructor.

In option A, super() is called first, then this(10), which is invalid because this() or super() must be the first statement and only one can be called.

🚀 Application

expert

Number of times constructors are called in chaining

Given the following Java classes, how many times is the constructor of class A called when creating new C()?

Java

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

A 0

B 1

C 3

D 2

💡 Hint

Trace constructor calls from C() up to A(), count how many times A() runs.

Creating new C() calls C(), which calls B() no-arg, which calls B(int) via this(5). B(int) calls super() which calls A() once. So A() is called once.

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