super Keyword in Java: Calling Parent Constructors and Methods Explained

The super keyword in Java is a reference variable used to access parent class members. It plays a crucial role in inheritance, especially when calling parent constructors and overridden methods.

📌 What is the `super` Keyword?

Definition: super refers to the immediate parent class object.
Why it matters: Ensures proper initialization and allows reusing parent behavior.
When to use: When you want to call parent constructors, access overridden methods, or parent class variables.

[Related: link-to-other-article]

🔹 Using `super` to Call Parent Constructors

✅ Rules:

super() must be the first statement in a subclass constructor.
If not explicitly called, Java inserts a default super().

💻 Example:

class Animal {
    Animal() {
        System.out.println("Animal constructor");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // Calls parent constructor
        System.out.println("Dog constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        new Dog();
    }
}

Output:

Animal constructor
Dog constructor

Parameterized Constructor Example:

class Animal {
    Animal(String name) {
        System.out.println("Animal: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // Passes argument to parent constructor
        System.out.println("Dog: " + name);
    }
}

🔹 Using `super` to Call Parent Methods

When a method is overridden, super.methodName() can call the parent version.

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

class Dog extends Animal {
    @Override
    void sound() {
        super.sound(); // Calls parent method
        System.out.println("Dog barks");
    }
}

🔹 Accessing Parent Variables

class Animal {
    String type = "Animal";
}

class Dog extends Animal {
    String type = "Dog";

    void showType() {
        System.out.println(super.type); // Access parent variable
    }
}

🔹 Real-World Analogy

Think of super as calling your parents for help. You inherit traits (methods/fields) but can still rely on them to handle certain responsibilities.

🚫 Common Mistakes and Anti-Patterns

❌ Forgetting super() in subclasses when parent has no default constructor.
❌ Using super in static contexts (not allowed).
❌ Overusing super when method overriding isn’t required.

📈 Performance and Memory Implications

super incurs no extra runtime overhead; it’s resolved at compile-time.
Ensures consistent object initialization in inheritance hierarchies.

Usage	Impact
Calling constructors	Proper object initialization
Calling methods	Access to parent behavior

🔧 Best Practices

Always call super() explicitly when parent has parameterized constructors.
Use super.method() to enhance, not duplicate, parent behavior.
Keep constructor chains simple and predictable.

📚 Interview Questions

Q: What happens if you don’t call super() in a subclass?
A: Compiler inserts a default super() if parent has a no-arg constructor.
Q: Can super be used to call grandparent methods?
A: No, it only refers to the immediate parent.
Q: Can you use this() and super() in the same constructor?
A: No, both must be the first statement.

📌 Java Version Relevance

Java Version	Change
Java 1.0	Introduced `super` keyword
Java 5	@Override introduced, making `super.method()` safer

✅ Conclusion & Key Takeaways

super ensures proper parent initialization and access to overridden behavior.
Use it in constructors and methods to maintain clean inheritance hierarchies.
Avoid misusing super in contexts where composition is better.

❓ FAQ

Q: Can super be used in static methods?
A: No, it requires an instance context.

Q: Is calling super() mandatory?
A: Only if the parent has no default constructor.

Q: Can super be used in multiple inheritance?
A: Java doesn’t support multiple inheritance for classes, so no.