Constructor chaining in Java - Mini Project: Build & Apply

Constructor chaining

📖 Scenario: Imagine you are creating a simple Java class to represent a Book in a library system. Each book has a title, author, and yearPublished. You want to practice how constructors can call each other to avoid repeating code.

🎯 Goal: You will build a Book class with three constructors. The constructors will use constructor chaining to reuse code and set default values when some information is missing.

📋 What You'll Learn

Create a Book class with three constructors

Use constructor chaining to call one constructor from another

Set default values for missing parameters using constructor chaining

Print the book details using a method

💡 Why This Matters

🌍 Real World

Constructor chaining helps reduce repeated code when creating objects with different levels of detail, common in real-world Java applications like library systems or inventory management.

💼 Career

Understanding constructor chaining is important for writing clean, maintainable Java code and is often asked in Java developer interviews.

1

Create the Book class with fields and a full constructor

Create a class called Book with three fields: String title, String author, and int yearPublished. Then write a constructor with parameters String title, String author, and int yearPublished that sets these fields.

Java

public class Book {
    String title;
    String author;
    int yearPublished;

    // Your code here
}

Hint

Remember to declare the fields first, then create the constructor with the same parameter names and assign them to the fields using this.

2

Add a constructor with two parameters using constructor chaining

Add a second constructor to the Book class with parameters String title and String author. Use this(title, author, 0) to call the first constructor and set yearPublished to 0 by default.

Java

public class Book {
    String title;
    String author;
    int yearPublished;

    public Book(String title, String author, int yearPublished) {
        this.title = title;
        this.author = author;
        this.yearPublished = yearPublished;
    }

    // Your code here
}

Hint

Use this(...) inside the second constructor to call the first constructor with a default year.

3

Add a constructor with only title using constructor chaining

Add a third constructor to the Book class with only the parameter String title. Use this(title, "Unknown Author") to call the second constructor and set author to "Unknown Author" by default.

Java

public class Book {
    String title;
    String author;
    int yearPublished;

    public Book(String title, String author, int yearPublished) {
        this.title = title;
        this.author = author;
        this.yearPublished = yearPublished;
    }

    public Book(String title, String author) {
        this(title, author, 0);
    }

    // Your code here
}

Hint

Use this(title, "Unknown Author") to reuse the second constructor and set a default author.

4

Add a method to print book details and test all constructors

Add a method void printDetails() to the Book class that prints the book's title, author, and yearPublished. Then create a main method that creates three Book objects using each constructor and calls printDetails() on each.

Java

public class Book {
    String title;
    String author;
    int yearPublished;

    public Book(String title, String author, int yearPublished) {
        this.title = title;
        this.author = author;
        this.yearPublished = yearPublished;
    }

    public Book(String title, String author) {
        this(title, author, 0);
    }

    public Book(String title) {
        this(title, "Unknown Author");
    }

    // Your code here
}

Hint

Print the details in printDetails() using System.out.println. In main, create three books using each constructor and call printDetails() on each.

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