Why interfaces are used in Java - Performance Analysis

Time Complexity: Why interfaces are used

O(n)

Understanding Time Complexity

We want to understand how using interfaces affects the time it takes for a program to run.

Specifically, we ask: Does calling methods through interfaces change how fast the program runs as it grows?

Scenario Under Consideration

Analyze the time complexity of calling a method through an interface reference.

interface Animal {
    void sound();
}

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

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        for (int i = 0; i < 1000; i++) {
            a.sound();
        }
    }
}
    

This code calls the sound() method 1000 times through an interface reference.

Identify Repeating Operations

Look for repeated actions that take time.

• Primary operation: Calling sound() method through the interface a.
• How many times: 1000 times in the loop.

How Execution Grows With Input

As the number of calls increases, the total time grows in a straight line.

Input Size (n)	Approx. Operations
10	10 method calls
100	100 method calls
1000	1000 method calls

Pattern observation: The time grows directly with the number of calls, no extra hidden cost from using interfaces.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with how many times you call the method, even when using interfaces.

Common Mistake

[X] Wrong: "Using interfaces makes method calls much slower and changes the time complexity."

[OK] Correct: Calling methods through interfaces adds a tiny fixed cost but does not change how time grows with more calls. The overall time still grows linearly.

Interview Connect

Understanding how interfaces affect performance helps you write clear code without worrying about slowing down your program as it grows.

Self-Check

What if we replaced the interface call with a direct class method call? How would the time complexity change?