Method overriding in Java - Time & Space Complexity

Time Complexity: Method overriding

O(n)

Understanding Time Complexity

Let's see how the time it takes to run a program changes when we use method overriding in Java.

We want to know if calling an overridden method takes more time as the program grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

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

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

This code shows a class Animal with a method sound, and a Dog class that changes (overrides) this method. We call the sound method on a Dog object through an Animal reference.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the overridden method sound()
• How many times: Called once in this example, but could be called many times in a larger program

How Execution Grows With Input

Calling an overridden method takes about the same time no matter how many classes or objects you have.

Input Size (n)	Approx. Operations
10	10 method calls, each takes similar time
100	100 method calls, each takes similar time
1000	1000 method calls, each takes similar time

Pattern observation: Each method call takes a fixed amount of time, so total time grows linearly with the number of calls.

Final Time Complexity

Time Complexity: O(n)

This means if you call the overridden method n times, the total time grows in a straight line with n.

Common Mistake

[X] Wrong: "Overriding a method makes the program slower because it adds extra steps."

[OK] Correct: The program uses a simple way to find the right method to run, so each call still takes about the same time as a normal method call.

Interview Connect

Understanding how method overriding affects time helps you explain how programs stay efficient even when using flexible designs.

Self-Check

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