Static methods in interfaces in Java - Step-by-Step Execution

Concept Flow - Static methods in interfaces

Define interface with static method

↓

Call static method via interface name

↓

Execute static method body

↓

Return result or perform action

↓

End

Static methods in interfaces are defined inside the interface and called using the interface name without needing an instance.

Execution Sample

Java

interface MyInterface {
    static void greet() {
        System.out.println("Hello from static method in interface");
    }
}

public class Test {
    public static void main(String[] args) {
        MyInterface.greet();
    }
}

This code defines a static method greet inside an interface and calls it using the interface name.

Execution Table

Step	Action	Evaluation	Result
1	Define interface MyInterface with static method greet()	Method greet() is stored in interface	Ready to call greet()
2	Call MyInterface.greet() in main method	Static method call via interface name	Method greet() starts execution
3	Execute System.out.println inside greet()	Print message to console	Output: Hello from static method in interface
4	greet() method finishes	Return void	Control returns to main
5	main method finishes	Program ends	No more output

💡 Program ends after main method completes

Variable Tracker

Variable	Start	After greet() call	Final
No instance variables	N/A	N/A	N/A

Key Moments - 2 Insights

Why do we call the static method using the interface name and not an object?

Static methods belong to the interface itself, not to any object, so we call them using the interface name as shown in step 2 of the execution table.

Can we override static methods in interfaces in implementing classes?

No, static methods in interfaces cannot be overridden by implementing classes; they belong only to the interface, as seen in the execution flow where greet() is called directly from the interface.

Visual Quiz - 3 Questions

Look at the execution table, what is printed to the console at step 3?

A "Hello from instance method"

B "Hello from static method in interface"

C Nothing is printed

D Compilation error

💡 Hint

Check the 'Result' column in step 3 of the execution table.

At which step does the static method greet() start executing?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Action' column to find when greet() is called.

If we tried to call greet() on an instance of a class implementing MyInterface, what would happen?

A It would cause a compile-time error

B It would call an instance method instead

C It would call the static method successfully

D It would call a default method

💡 Hint

Static methods in interfaces must be called using the interface name, not instances (see key moments).

Concept Snapshot

Static methods in interfaces:
- Declared with 'static' keyword inside interface
- Called using InterfaceName.methodName()
- Cannot be overridden by implementing classes
- Useful for utility or helper methods related to interface
- Do not require an instance to be called

Full Transcript

This example shows how to define and use static methods in Java interfaces. The interface MyInterface has a static method greet() that prints a message. In the main method, we call MyInterface.greet() directly using the interface name. The static method runs and prints the message to the console. Static methods in interfaces belong to the interface itself and cannot be called on instances or overridden by classes. This makes them useful for helper methods related to the interface's purpose.

Practice

1. What is the correct way to call a static method calculate() defined inside an interface MathOps?

easy

A. MathOps.calculate()

B. new MathOps().calculate()

C. calculate()

D. MathOps obj = new MathOps(); obj.calculate()

Solution

1. Step 1: Understand static method call in interfaces

   Static methods in interfaces are called using the interface name, not instances.

2. Step 2: Analyze the options

   Only MathOps.calculate() correctly calls the static method. Creating instances or calling directly is invalid.

3. Final Answer:

   MathOps.calculate() -> Option A

4. Quick Check:

   Static method call = InterfaceName.method() [OK]

Hint: Call static interface methods with InterfaceName.method() [OK]

Common Mistakes:

• Trying to call static method on an instance
• Calling static method without interface name
• Trying to instantiate an interface

2. Which of the following is the correct syntax to declare a static method printMessage inside an interface Logger?

easy

A. static void printMessage();

B. static void printMessage() { System.out.println("Hello"); }

C. public static void printMessage();

D. void static printMessage() { System.out.println("Hello"); }

Solution

1. Step 1: Recall static method syntax in interfaces

   Static methods must have a body and use static keyword before return type.

2. Step 2: Check each option

   Only static void printMessage() { System.out.println("Hello"); } correctly declares and defines the static method. Declarations without a body or with static after the return type are invalid.

3. Final Answer:

   static void printMessage() { System.out.println("Hello"); } -> Option B

4. Quick Check:

   Static method = static + return type + name + () + body [OK]

Hint: Static methods in interfaces need a body and static keyword first [OK]

Common Mistakes:

• Omitting method body in static method
• Placing static keyword after return type
• Declaring static methods without body

3. What will be the output of the following code?

interface Helper {
    static String greet() {
        return "Hi!";
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(Helper.greet());
    }
}

medium

A. Runtime error

B. Compile-time error

C. null

D. Hi!

Solution

1. Step 1: Understand static method call in interface

   The static method greet() is called correctly using Helper.greet().

2. Step 2: Predict output

   The method returns "Hi!" which is printed by System.out.println.

3. Final Answer:

   Hi! -> Option D

4. Quick Check:

   Static method returns "Hi!" printed [OK]

Hint: Static interface methods run when called by InterfaceName.method() [OK]

Common Mistakes:

• Trying to call static method on instance
• Expecting compile error due to interface method
• Confusing static with default methods

4. Identify the error in the following code snippet:

interface Calculator {
    static int add(int a, int b) {
        return a + b;
    }
}

public class Demo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));
    }
}

medium

A. Missing return statement in add()

B. Static method add() cannot be called on instance

C. Cannot instantiate interface Calculator

D. No error, code runs fine

Solution

1. Step 1: Check interface instantiation

   Interfaces cannot be instantiated directly using new.

2. Step 2: Analyze method call

   Static methods must be called using interface name, not instance. But the main error is instantiating interface.

3. Final Answer:

   Cannot instantiate interface Calculator -> Option C

4. Quick Check:

   Interfaces cannot be instantiated [OK]

Hint: Interfaces cannot be created with new keyword [OK]

Common Mistakes:

• Trying to instantiate interface
• Calling static method on instance
• Ignoring compile errors on interface instantiation

5. Given the interface Utils with a static method isEven(int n) that returns true if n is even, how can you use this method inside a class NumberChecker to filter even numbers from a list List<Integer> nums using streams?

hard

A. nums.stream().filter(Utils::isEven).toList();

B. nums.stream().filter(n -> Utils.isEven()).toList();

C. nums.stream().filter(n -> isEven(n)).toList();

D. nums.stream().filter(n -> Utils.isEven(n)).collect();

Solution

1. Step 1: Understand method reference syntax

   Static methods can be referenced as InterfaceName::methodName in streams.

2. Step 2: Analyze options for correct syntax

   nums.stream().filter(Utils::isEven).toList(); uses method reference correctly. The lambda n -> Utils.isEven() misses argument n, n -> isEven(n) lacks interface qualification, and .collect() requires a collector.

3. Final Answer:

   nums.stream().filter(Utils::isEven).toList(); -> Option A

4. Quick Check:

   Use InterfaceName::staticMethod for stream filters [OK]

Hint: Use InterfaceName::methodName for static method references in streams [OK]

Common Mistakes:

• Calling static method without argument in lambda
• Using instance method syntax for static methods
• Wrong terminal operation like collect() without collector