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.

🔧 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

1. 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.

2. Q: Can super be used to call grandparent methods?
   A: No, it only refers to the immediate parent.

3. Q: Can you use this() and super() in the same constructor?
   A: No, both must be the first statement.

📌 Java Version Relevance

✅ 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.