Constructor overloading in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of overloaded constructors with different parameters

What is the output of this Java program using constructor overloading?

Java

public class Box {
    int width, height, depth;

    Box() {
        width = height = depth = 1;
    }

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }

    void display() {
        System.out.println("Volume: " + (width * height * depth));
    }

    public static void main(String[] args) {
        Box b1 = new Box();
        Box b2 = new Box(2, 3, 4);
        b1.display();
        b2.display();
    }
}

A

Volume: 0
Volume: 0

B

Volume: 0
Volume: 24

C

Volume: 1
Volume: 9

D

Volume: 1
Volume: 24

💡 Hint

Check how the default constructor sets all dimensions to 1.

The default constructor sets width, height, and depth to 1, so volume is 1*1*1=1. The overloaded constructor sets them to 2,3,4, so volume is 24.

❓ Predict Output

intermediate

Which constructor is called?

Given this Java class with overloaded constructors, what will be printed when creating an object with new Person("Alice")?

Java

public class Person {
    String name;
    int age;

    Person() {
        name = "Unknown";
        age = 0;
        System.out.println("Default constructor called");
    }

    Person(String n) {
        name = n;
        age = 18;
        System.out.println("Constructor with name called");
    }

    Person(String n, int a) {
        name = n;
        age = a;
        System.out.println("Constructor with name and age called");
    }

    public static void main(String[] args) {
        Person p = new Person("Alice");
    }
}

A Constructor with name called

B Constructor with name and age called

C Default constructor called

D Compilation error

💡 Hint

Look at the constructor signatures and which matches the argument.

The constructor Person(String n) matches the call new Person("Alice"), so it prints "Constructor with name called".

🔧 Debug

advanced

Identify the compilation error in constructor overloading

Why does this Java class fail to compile?

Java

public class Car {
    String model;
    int year;

    Car(String m) {
        model = m;
    }

    Car(String m, int y) {
        model = m;
        year = y;
    }

    Car(String m, int y) {
        model = m;
        year = y + 1;
    }
}

A Cannot overload constructors with different parameter counts

B Missing return type in constructors

C Duplicate constructor with same parameter types

D Constructor names do not match class name

💡 Hint

Check if any constructors have identical parameter lists.

Two constructors have the same parameter types (String, int), which causes a duplicate method error.

❓ Predict Output

advanced

Output of constructor chaining with this()

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

Java

public class Animal {
    String type;
    int legs;

    Animal() {
        this("Unknown");
        System.out.println("No-arg constructor");
    }

    Animal(String t) {
        this(t, 4);
        System.out.println("One-arg constructor");
    }

    Animal(String t, int l) {
        type = t;
        legs = l;
        System.out.println("Two-arg constructor");
    }

    public static void main(String[] args) {
        Animal a = new Animal();
    }
}

A

No-arg constructor
One-arg constructor
Two-arg constructor

B

Two-arg constructor
One-arg constructor
No-arg constructor

C

One-arg constructor
Two-arg constructor
No-arg constructor

D Compilation error due to constructor chaining

💡 Hint

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

The no-arg constructor calls the one-arg constructor, which calls the two-arg constructor. The print statements execute after each call returns, so the order is two-arg, one-arg, no-arg.

🧠 Conceptual

expert

Why constructor overloading improves code design?

Which of the following best explains why constructor overloading is useful in Java?

A It enables creating objects with different initial data by providing multiple constructor options.

B It allows creating multiple constructors with the same parameters but different names.

C It forces all constructors to have the same number of parameters for consistency.

D It automatically generates default constructors if none are defined.

💡 Hint

Think about how constructors help initialize objects in different ways.

Constructor overloading lets you create objects with different sets of initial data by defining multiple constructors with different parameter lists.