Source: Dev.to

📚 Constructors & Inheritance – Tricky Scenarios Explained

Discussing tricky scenarios, let’s break this clearly and powerfully 💪

---

✅ 1️⃣ Golden Rule of Constructors in Inheritance

When a child object is created:

1. Parent constructor executes first
2. Then Child constructor executes

Because every child‑class constructor implicitly or explicitly calls super().

---

🎯 Scenario 1 – Parent has a no‑arg constructor

class Parent {
    Parent() {
        System.out.println("Parent No-Arg Constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child No-Arg Constructor");
    }

    public static void main(String[] args) {
        new Child();
    }
}

Output

Parent No-Arg Constructor
Child No-Arg Constructor

✔ Java automatically inserts super();.

---

🎯 Scenario 2 – Parent has only a parameterized constructor

class Parent {
    Parent(int x) {
        System.out.println("Parent Parameterized Constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child Constructor");
    }
}

❌ Compile‑time error!

Why? Java tries to insert super(); (the default no‑arg call), but Parent does not have a no‑arg constructor.

✅ Correct way

class Child extends Parent {
    Child() {
        super(10);               // must call explicitly
        System.out.println("Child Constructor");
    }
}

---

🎯 Scenario 3 – Parent has both constructors

class Parent {
    Parent() {
        System.out.println("Parent No-Arg");
    }

    Parent(int x) {
        System.out.println("Parent Parameterized");
    }
}

class Child extends Parent {
    Child() {
        super(100);               // choose which parent constructor to call
        System.out.println("Child Constructor");
    }
}

✔ You can decide which parent constructor to invoke.

---

🎯 Scenario 4 – Child has a parameterized constructor

class Child extends Parent {
    Child(int y) {
        super(y);
        System.out.println("Child Parameterized");
    }
}

✔ Parent constructor runs first.

---

🎯 Scenario 5 – Constructor chaining within the same class (this())

class Child extends Parent {

    Child() {
        this(10);                 // calls another constructor of the same class
        System.out.println("Child No-Arg");
    }

    Child(int x) {
        super(x);
        System.out.println("Child Parameterized");
    }
}

Important Rules

• this() must be the first line in a constructor.
• super() must be the first line in a constructor.
• You cannot use both this() and super() in the same constructor.

---

🎯 Scenario 6 – Multi‑level inheritance

class GrandParent {
    GrandParent() {
        System.out.println("GrandParent");
    }
}

class Parent extends GrandParent {
    Parent() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child");
    }

    public static void main(String[] args) {
        new Child();
    }
}

Output

GrandParent
Parent
Child

✔ Constructor calls happen top → down.

---

🎯 Scenario 7 – Parent constructor is private

class Parent {
    private Parent() {
        System.out.println("Private Constructor");
    }
}

class Child extends Parent { }

❌ Compile‑time error – the child cannot access the private constructor.

---

🎯 Scenario 8 – What if you don’t write any constructor?

• Java provides a default no‑arg constructor only when no constructor is declared in the class.
• As soon as you write any constructor, the default one is not generated.

---

🔥 Very Important Tricky Question

class Parent {
    Parent(int x) {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child");
    }

    public static void main(String[] args) {
        new Child();
    }
}

❓ What happens?

👉 Compile‑time error – Parent lacks a no‑arg constructor, and Child does not explicitly call super(int).

---

🧠 Memory Cheat‑Sheet

---

💎 About Wrapper Classes & “100 % OOP”

• Primitive – not an object.
• Wrapper – an object that represents a primitive.

int a = 10;          // primitive
Integer b = 10;      // wrapper (object)

✔ Java achieves “almost” 100 % OOP by providing wrapper classes for all primitives.

---

💡 About var (Java 10 Feature)

var x = 100;   // type inferred as int

• Allowed only for local variables.
• Not allowed for:
  • Class (field) variables
  • Method parameters
  • Return types

---

Date: 04/03/2026
Trainer: Nantha from

---

# Payilagam

🤖 **A Small Note**

I used ChatGPT to help me structure and refine this blog.