🌟 Introduction
In the previous articles, we explored:
- Inheritance
- Method Overriding
superkeyword
Now comes a very important concept that explains what happens during object creation:
👉 Constructors in Inheritance (Constructor Chaining)
Whenever we create an object of a child class:
Dog d = new Dog();
Many students wonder:
- Which constructor runs first?
- Parent or child?
- Do both run?
- How does Java decide?
👉 These questions are answered by constructor chaining.
Understanding this concept is extremely important because it explains how Java initializes objects step by step.
🧠 What is Constructor Chaining?
Constructor chaining means:
When a child class object is created, constructors of all parent classes are executed in a chain.
💡 Key Idea
👉 Parent constructor runs before child constructor.
🧱 Basic Example (Default Constructors)
💻 Code
class Animal {
Animal() {
System.out.println("Animal Constructor");
}
}
class Dog extends Animal {
Dog() {
System.out.println("Dog Constructor");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
}
}🔎 Step-by-Step Execution
Dog d = new Dog();
Execution flow:
1️⃣ Dog constructor is called
2️⃣ Before executing Dog constructor → Java calls Animal constructor
3️⃣ Then Dog constructor runs
🧾 Output
Animal Constructor
Dog Constructor
🧠 Important Concept
Even if you do not write super(), Java automatically inserts:
super();
as the first line of child constructor.
🔹 Using super() Explicitly
💻 Code
class Animal {
Animal() {
System.out.println("Animal Constructor");
}
}
class Dog extends Animal {
Dog() {
super();
System.out.println("Dog Constructor");
}
}🔎 Explanation
super();
👉 Calls parent constructor explicitly
👉 Must be the first statement
🔥 Parameterized Constructor with super()
💻 Code
class Animal {
Animal(String name) {
System.out.println("Animal: " + name);
}
}
class Dog extends Animal {
Dog() {
super("Dog Parent");
System.out.println("Dog Constructor");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog();
}
}🔎 Explanation
super("Dog Parent");
👉 Calls parameterized constructor of parent
🧾 Output
Animal: Dog Parent
Dog Constructor
⚠️ Important Rule
If parent has only parameterized constructor, then:
👉 Child must call it using super(parameters)
Otherwise → ❌ Compile-time error
🚫 Common Error (Very Important)
💻 Code
class Animal {
Animal(String name) {
System.out.println(name);
}
}
class Dog extends Animal {
Dog() {
System.out.println("Dog");
}
}❌ Error
Constructor Animal() is undefined
🧠 Why?
👉 Java tries to call:
super();
But parent has no default constructor
✅ Fix
Dog() {
super("Animal");
System.out.println("Dog");
}
🌿 Multilevel Constructor Chaining
💻 Code
class Animal {
Animal() {
System.out.println("Animal Constructor");
}
}
class Dog extends Animal {
Dog() {
System.out.println("Dog Constructor");
}
}
class Puppy extends Dog {
Puppy() {
System.out.println("Puppy Constructor");
}
}
public class Main {
public static void main(String[] args) {
Puppy p = new Puppy();
}
}🔎 Execution Flow
Animal → Dog → Puppy
🧾 Output
Animal Constructor
Dog Constructor
Puppy Constructor
🧠 Important Insight
👉 Constructors execute top to bottom (parent → child)
⚙️ Rules of Constructor Chaining
✔ Rule 1: Parent Constructor Runs First
Always:
Parent → Child
✔ Rule 2: super() Must Be First Statement
Dog() {
super();
}
✔ Rule 3: If Not Written, Java Inserts super()
Default behavior.
✔ Rule 4: Only One Constructor Call Allowed
You cannot write both:
this();
super(); // ❌ not allowed together
✔ Rule 5: Constructor is Not Inherited
Child class does NOT inherit constructors.
🔄 this() vs super()
| Feature | this() | super() |
|---|---|---|
| Refers to | Same class constructor | Parent class constructor |
| Use | Constructor chaining within class | Parent constructor call |
| Position | First line | First line |
🧨 Tricky Interview Example
class A {
A() {
System.out.println("A");
}
}
class B extends A {
B() {
System.out.println("B");
}
}
public class Main {
public static void main(String[] args) {
B obj = new B();
}
}🧾 Output
A
B
👉 Parent runs first — always
⚠️ Common Mistakes & Confusions
❌ Mistake 1: Thinking child constructor runs first
❌ Wrong
✔ Parent always runs first
❌ Mistake 2: Forgetting parameterized constructor
Leads to compile error
❌ Mistake 3: Writing super() after statements
Dog() {
System.out.println("Dog");
super(); // ❌ Error
}
❌ Mistake 4: Thinking constructors are inherited
❌ Constructors are NOT inherited
❌ Mistake 5: Using both this() and super()
❌ Not allowed together
🎯 Real-Life Analogy
Think of building a house:
Foundation → Walls → Roof
👉 Foundation (parent) must be built first
👉 Then upper layers (child)
🧠 Key Points to Remember
✔ Constructor chaining = Parent → Child
✔ super() is used to call parent constructor
✔ Java automatically inserts super()
✔ Parent constructor must exist
✔ Executes in top-down order
🏁 Conclusion
Constructors in inheritance explain how Java creates and initializes objects step by step.
This concept is extremely important because it:
- Defines object creation flow
- Ensures proper initialization
- Connects inheritance with real execution
- Helps avoid runtime and compile-time errors
In this article, we learned:
- What constructor chaining is
- Execution order of constructors
- Role of
super() - Parameterized constructor handling
- Common mistakes and interview traps
Mastering constructor chaining gives you a deep understanding of how Java works internally, making you a stronger programmer.
