5-🔑 super Keyword in Java – Complete Guide with Examples, Constructor Calls & Common Mistakes

🌟 Introduction

In the previous articles, we explored:

• Inheritance
• Types of Inheritance
• Method Overriding
• Parent Reference & Child Object

Now comes a very important concept that connects all of these together:

👉 The super keyword

When we use inheritance, a child class inherits properties and methods from the parent class. But sometimes, the child class:

• Has variables with the same name as the parent
• Overrides parent methods
• Needs to call the parent constructor

In all these cases, Java provides a special keyword:

👉 super

Understanding super is essential because it helps us control and access parent class behavior, especially when overriding happens.

---

🧠 What is super Keyword?

👉 super is a reference variable in Java that is used to refer to the immediate parent class object.

In simple words:

super allows a child class to access the parent class members.

---

🎯 Where is super Used?

The super keyword is mainly used in three ways:

1️⃣ To access parent class variables
2️⃣ To call parent class methods
3️⃣ To call parent class constructors

Let’s understand each one in detail.

---

🔹 1. Accessing Parent Class Variable Using super

---

💻 Example

class Animal {

    String name = "Animal";

}

class Dog extends Animal {

    String name = "Dog";

    void printName() {
        System.out.println(name);
        System.out.println(super.name);
    }

}

public class Main {

    public static void main(String[] args) {

        Dog d = new Dog();
        d.printName();

    }

}

---

🔎 Explanation

String name = "Animal";

Parent class variable

---

String name = "Dog";

Child class variable (same name)

---

System.out.println(name);

👉 Refers to current class variable (Dog)

---

System.out.println(super.name);

👉 Refers to parent class variable (Animal)

---

🧾 Output

Dog
Animal

---

⚠️ Important Concept

👉 If both parent and child have same variable names:

• this.name → child class
• super.name → parent class

---

🔹 2. Calling Parent Class Method Using super

---

💻 Example

class Animal {

    void sound() {
        System.out.println("Animal makes sound");
    }

}

class Dog extends Animal {

    void sound() {
        super.sound();
        System.out.println("Dog barks");
    }

}

public class Main {

    public static void main(String[] args) {

        Dog d = new Dog();
        d.sound();

    }

}

---

🔎 Explanation

Child method:

void sound()

Overrides parent method

---

super.sound();

👉 Calls parent class version of method

---

🧾 Output

Animal makes sound
Dog barks

---

🔥 Key Insight

👉 Without super, parent method would not be called
👉 With super, both parent + child behavior can be combined

---

🔹 3. Calling Parent Class Constructor Using super()

---

💻 Example

class Animal {

    Animal() {
        System.out.println("Animal Constructor");
    }

}

class Dog extends Animal {

    Dog() {
        super();
        System.out.println("Dog Constructor");
    }

}

public class Main {

    public static void main(String[] args) {

        Dog d = new Dog();

    }

}

---

🔎 Explanation

super();

👉 Calls parent class constructor

---

🧾 Output

Animal Constructor
Dog Constructor

---

⚠️ Important Rule

👉 super() must be the first statement in constructor

---

🧠 Hidden Behavior

Even if you don’t write:

super();

👉 Java automatically inserts it (default constructor case)

---

⚙️ Rules of super Keyword

---

✔ Rule 1: Refers to Immediate Parent

super can only access direct parent, not grandparent.

---

✔ Rule 2: Cannot Be Used in Static Context

static void method() {
    // super not allowed here ❌
}

---

✔ Rule 3: Must Be First Statement in Constructor

Dog() {
    super(); // must be first
}

---

✔ Rule 4: Used Only Inside Child Class

super is meaningful only in inheritance

---

🔄 this vs super (Very Important)

Feature	this	super
Refers to	Current class	Parent class
Access	Own members	Parent members
Constructor	this()	super()

---

🧨 Tricky Interview Example

class A {

    int x = 10;

}

class B extends A {

    int x = 20;

    void show() {
        System.out.println(x);
        System.out.println(super.x);
    }

}

public class Main {

    public static void main(String[] args) {

        B obj = new B();
        obj.show();

    }

}

---

🧾 Output

20
10

---

⚠️ Common Mistakes & Confusions

---

❌ Mistake 1: Forgetting super() position

Dog() {
    System.out.println("Dog");
    super(); // ❌ Error
}

---

❌ Mistake 2: Confusing this and super

👉 this → current class
👉 super → parent class

---

❌ Mistake 3: Using in static method

static void test() {
    super.sound(); // ❌ Not allowed
}

---

❌ Mistake 4: Thinking super accesses all ancestors

❌ Only immediate parent

---

🎯 Real-Life Analogy

Think:

Child → refers to Parent using "super"

Just like:

👉 You calling your parent for help

---

🧠 Key Points to Remember

✔ super refers to parent class object
✔ Used for variables, methods, constructors
✔ Helps resolve overriding conflicts
✔ Must be first in constructor
✔ Cannot be used in static context

---

🏁 Conclusion

The super keyword is a powerful feature in Java that allows a child class to access and interact with its parent class.

It plays a crucial role in:

• Method overriding
• Constructor chaining
• Resolving variable conflicts

In this article, we learned:

• What super is
• How to access parent variables
• How to call parent methods
• How constructors work with super()
• Common mistakes and interview traps

Mastering super helps you understand how inheritance works internally, making your code more structured and maintainable.

---