super Keyword in Java: Calling Parent Constructors and Methods Explained

Illustration for super Keyword in Java: Calling Parent Constructors and Methods Explained
By Last updated:

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

  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

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.