Multiple inheritance using interfaces in Java - Time & Space Complexity

Time Complexity: Multiple inheritance using interfaces

O(1)

Understanding Time Complexity

We want to understand how the time needed to run code changes when using multiple inheritance with interfaces in Java.

Specifically, how does calling methods from multiple interfaces affect the program's speed as the input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

interface A {
    void methodA();
}

interface B {
    void methodB();
}

class C implements A, B {
    public void methodA() { System.out.println("A"); }
    public void methodB() { System.out.println("B"); }
}

public class Test {
    public static void main(String[] args) {
        C obj = new C();
        obj.methodA();
        obj.methodB();
    }
}
    

This code shows a class implementing two interfaces and calling their methods.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling methods from two interfaces once each.
• How many times: Each method is called exactly once; no loops or recursion.

How Execution Grows With Input

Since there are no loops or repeated calls, the number of operations stays the same no matter how big the input is.

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

Pattern observation: The work does not increase with input size; it stays constant.

Final Time Complexity

Time Complexity: O(1)

This means the time to run the code stays the same no matter how big the input is.

Common Mistake

[X] Wrong: "Using multiple interfaces makes the program slower as input grows because it has more methods to call."

[OK] Correct: The number of method calls here is fixed and does not depend on input size, so the time does not grow with input.

Interview Connect

Understanding how multiple inheritance with interfaces affects time helps you explain design choices clearly and shows you know how code structure relates to performance.

Self-Check

"What if each method called inside the interfaces contained a loop over an input array? How would the time complexity change?"