Abstract methods in Java - Time & Space Complexity

Time Complexity: Abstract methods

O(1)

Understanding Time Complexity

We want to understand how the time it takes to run code with abstract methods changes as the program grows.

Specifically, how calling abstract methods affects the number of steps the program takes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

abstract class Animal {
    abstract void sound();
}

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

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
    }
}

This code defines an abstract method and calls it through a subclass instance.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the abstract method sound() once.
• How many times: Exactly one time in this example.

How Execution Grows With Input

Since the method is called only once, the number of steps stays the same no matter how big the program or input is.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The execution steps do not increase with input size here.

Final Time Complexity

Time Complexity: O(1)

This means the time to call an abstract method once stays constant regardless of input size.

Common Mistake

[X] Wrong: "Calling an abstract method is slower and grows with input size because it uses dynamic dispatch."

[OK] Correct: Dynamic dispatch adds a tiny fixed cost per call, but it does not grow with input size. The call time stays constant.

Interview Connect

Understanding that abstract methods add a fixed call cost helps you explain how object-oriented features affect performance clearly and confidently.

Self-Check

"What if the abstract method is called inside a loop that runs n times? How would the time complexity change?"