Constructor overloading in Java - Step-by-Step Execution

Concept Flow - Constructor overloading

Create object

↓

Check constructor parameters

↓

Call default constructor

↓

Call constructor with int

↓

Call constructor with two args

↓

Initialize object fields

↓

Object ready to use

When creating an object, Java chooses the constructor matching the given parameters to initialize the object.

Execution Sample

Java

class Box {
  int width, height;
  Box() { width = 0; height = 0; }
  Box(int w) { width = w; height = w; }
  Box(int w, int h) { width = w; height = h; }
}

Defines a Box class with three constructors: no parameters, one int, and two ints.

Execution Table

Step	Constructor Called	Parameters	Field width	Field height	Action
1	Box()	none	0	0	Default constructor sets width and height to 0
2	Box(int w)	5	5	5	Single parameter constructor sets width and height to w
3	Box(int w, int h)	3, 7	3	7	Two parameter constructor sets width and height separately
4	End	-	-	-	All objects created with correct fields

💡 All constructors executed as per parameters; object initialization complete.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
width	undefined	0	5	3	3
height	undefined	0	5	7	7

Key Moments - 3 Insights

Why does Java choose different constructors for the same class?

Java matches the constructor parameters with the arguments used during object creation, as shown in execution_table rows 1-3.

What happens if no constructor matches the parameters?

Java will give a compile-time error because it cannot find a suitable constructor, unlike the examples where parameters match exactly.

Are the fields initialized differently in each constructor?

Yes, each constructor sets the fields differently based on the parameters, as seen in the field values in execution_table rows 1-3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of height after step 2?

A 0

B 5

C 7

D undefined

💡 Hint

Check the 'Field height' column in execution_table row 2.

At which step does the constructor set width to 3?

A Step 1

B Step 2

C Step 3

D No step

💡 Hint

Look at the 'Field width' column in execution_table rows.

If we create a Box object with no parameters, which constructor is called?

A Box()

B Box(int w, int h)

C Box(int w)

D No constructor

💡 Hint

Refer to execution_table row 1 for constructor called with no parameters.

Concept Snapshot

Constructor overloading means having multiple constructors with different parameters.
Java picks the constructor matching the arguments when creating an object.
Each constructor can initialize fields differently.
If no matching constructor exists, code won't compile.
Use overloading to create flexible object initialization.

Full Transcript

Constructor overloading in Java allows a class to have multiple constructors with different parameter lists. When an object is created, Java chooses the constructor that matches the given arguments. For example, a Box class can have a default constructor with no parameters, one with a single integer parameter, and one with two integer parameters. Each constructor sets the object's fields differently. This lets you create objects in different ways. If you try to create an object with parameters that don't match any constructor, Java will give an error. The execution table shows step-by-step which constructor is called and how the fields change. This helps understand how overloading works in practice.

Practice

1.

What is constructor overloading in Java?

easy

A. Having multiple constructors with different parameter lists in the same class.

B. Using the same constructor name with the same parameters multiple times.

C. Creating constructors only with no parameters.

D. Defining constructors outside the class.

Solution

1. Step 1: Understand constructor overloading definition

   Constructor overloading means having more than one constructor in a class, each with a different set of parameters.

2. Step 2: Check options against definition

   Having multiple constructors with different parameter lists in the same class. correctly states this. Options B, C, and D are incorrect because they describe invalid or unrelated concepts.

3. Final Answer:

   Having multiple constructors with different parameter lists in the same class. -> Option A

4. Quick Check:

   Constructor overloading = multiple constructors with different parameters [OK]

Hint: Look for multiple constructors with unique parameter lists [OK]

Common Mistakes:

• Thinking constructors must have different names
• Confusing overloading with overriding
• Believing constructors cannot have parameters

2.

Which of the following constructor declarations is correct for overloading?

public class Car {
    public Car() { }
    public Car(String model) { }
    public Car(int year) { }
    public Car(String model, int year) { }
}

easy

A. Only constructors with one parameter are allowed.

B. Constructors must have different names, so this is incorrect.

C. All constructors have different parameter lists, so all are correct.

D. Constructors cannot have parameters, so only the first is correct.

Solution

1. Step 1: Check parameter lists of constructors

   Each constructor has a unique parameter list: no parameters, one String, one int, and two parameters.

2. Step 2: Verify constructor overloading rules

   Constructors can share the same name but must differ in parameters. This code follows that rule.

3. Final Answer:

   All constructors have different parameter lists, so all are correct. -> Option C

4. Quick Check:

   Different parameters = valid overloading [OK]

Hint: Check if parameter lists differ, not constructor names [OK]

Common Mistakes:

• Thinking constructors need different names
• Believing constructors cannot have parameters
• Confusing method overloading rules with constructors

3.

What will be the output of the following code?

class Box {
    int width, height;
    Box() {
        width = 10;
        height = 10;
    }
    Box(int w, int h) {
        width = w;
        height = h;
    }
    void display() {
        System.out.println(width + "," + height);
    }
}

public class Test {
    public static void main(String[] args) {
        Box b1 = new Box();
        Box b2 = new Box(5, 15);
        b1.display();
        b2.display();
    }
}

medium

A. 10,10
5,15

B. 5,15
10,10

C. 10,10
10,10

D. Compilation error due to constructor overloading

Solution

1. Step 1: Identify which constructors are called

   b1 uses the no-argument constructor setting width and height to 10. b2 uses the two-parameter constructor setting width=5 and height=15.

2. Step 2: Understand display output

   b1.display() prints "10,10" and b2.display() prints "5,15" on separate lines.

3. Final Answer:

   10,10 5,15 -> Option A

4. Quick Check:

   Constructor sets values correctly, output matches [OK]

Hint: Match constructor parameters to object creation [OK]

Common Mistakes:

• Assuming default constructor sets zero values
• Mixing order of printed outputs
• Thinking overloading causes errors here

4.

Find the error in the following code snippet:

class Person {
    String name;
    int age;
    Person(String n) {
        name = n;
    }
    Person(String n, int a) {
        name = n;
        age = a;
    }
    Person() {
        this("Unknown");
        this(0);
    }
}

medium

A. Missing return type in constructors.

B. Cannot call two constructors using 'this()' in the same constructor.

C. Constructor names must be different for overloading.

D. No error; code is correct.

Solution

1. Step 1: Analyze constructor chaining rules

   In Java, a constructor can call only one other constructor using 'this()' and it must be the first statement.

2. Step 2: Identify the error in the no-argument constructor

   The no-argument constructor calls 'this("Unknown")' and then 'this(0)', which is not allowed.

3. Final Answer:

   Cannot call two constructors using 'this()' in the same constructor. -> Option B

4. Quick Check:

   Only one 'this()' call allowed per constructor [OK]

Hint: Only one 'this()' call allowed as first line in constructor [OK]

Common Mistakes:

• Trying to call multiple constructors with 'this()'
• Thinking constructor names must differ
• Forgetting 'this()' must be first statement

5.

Consider a class Employee with overloaded constructors:

class Employee {
    String name;
    int id;
    double salary;

    Employee(String name) {
        this.name = name;
        this.id = 0;
        this.salary = 0.0;
    }

    Employee(String name, int id) {
        this(name);
        this.id = id;
    }

    Employee(String name, int id, double salary) {
        this(name, id);
        this.salary = salary;
    }

    void display() {
        System.out.println(name + "," + id + "," + salary);
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e = new Employee("Alice", 101, 75000.0);
        e.display();
    }
}

What will be the output when running Main?

hard

A. Alice,101,0.0

B. Alice,0,0.0

C. Compilation error due to constructor chaining

D. Alice,101,75000.0

Solution

1. Step 1: Trace constructor calls for Employee("Alice", 101, 75000.0)

   The three-parameter constructor calls the two-parameter constructor with ("Alice", 101), which calls the one-parameter constructor with ("Alice").

2. Step 2: Understand field assignments

   The one-parameter constructor sets name="Alice", id=0, salary=0.0. The two-parameter constructor updates id=101. The three-parameter constructor updates salary=75000.0.

3. Step 3: Output values

   After all calls, name="Alice", id=101, salary=75000.0, so display prints "Alice,101,75000.0".

4. Final Answer:

   Alice,101,75000.0 -> Option D

5. Quick Check:

   Constructor chaining updates fields stepwise [OK]

Hint: Follow constructor calls step-by-step to track field values [OK]

Common Mistakes:

• Assuming fields reset after each constructor call
• Thinking constructor chaining causes errors
• Ignoring order of field assignments