Constructor chaining in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is constructor chaining in Java?

Constructor chaining is the process where one constructor calls another constructor in the same class or parent class to reuse code and initialize objects efficiently.

beginner

How do you call one constructor from another in the same class?

You use the keyword this() with appropriate parameters inside a constructor to call another constructor in the same class.

beginner

How do you call a parent class constructor from a child class constructor?

You use the keyword <code>super()</code> with parameters inside the child class constructor to call the parent class constructor.

beginner

Why is constructor chaining useful?

It helps avoid code duplication by reusing constructor code, making the code cleaner and easier to maintain.

intermediate

What happens if you don't explicitly call this() or super() in a constructor?

Java automatically inserts a call to the no-argument constructor of the parent class (super()) if no explicit call is made.

Which keyword is used to call another constructor in the same class?

A this()

B super()

C new

D constructor()

The keyword this() calls another constructor in the same class.

What does super() do in a constructor?

A Calls the parent class constructor

B Calls a constructor in the same class

C Creates a new object

D Calls a static method

super() calls the parent class constructor.

What is the main benefit of constructor chaining?

A Faster program execution

B Allows multiple inheritance

C Avoids code duplication

D Enables method overloading

Constructor chaining helps avoid code duplication by reusing constructor code.

If no constructor call is made explicitly, what does Java do?

A Skips constructor execution

B Calls <code>this()</code> automatically

C Throws an error

D Calls the parent class no-argument constructor

Java automatically calls the parent class no-argument constructor if no explicit call is made.

Can constructor chaining happen between different classes?

A Yes, using <code>this()</code>

B Yes, using <code>super()</code>

C No, only within the same class

D No, constructors cannot call each other

Constructor chaining between classes happens using super() to call parent class constructors.

Explain constructor chaining and how it helps in Java programming.

Think about how constructors can call each other to avoid repeating code.

Describe the difference between using this() and super() in constructors.

Consider the relationship between classes and constructors.

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