Static methods in interfaces in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a static method in a Java interface?

A static method in a Java interface is a method with a body that belongs to the interface itself, not to instances of classes that implement the interface. It can be called using the interface name.

beginner

How do you call a static method defined in a Java interface?

You call a static method in an interface using the interface name followed by the method name, like InterfaceName.methodName().

intermediate

Can static methods in interfaces be overridden by implementing classes?

No, static methods in interfaces cannot be overridden by implementing classes because they belong to the interface itself, not to instances.

intermediate

Why were static methods added to interfaces in Java 8?

Static methods were added to interfaces in Java 8 to allow utility or helper methods related to the interface without needing a separate class, improving code organization.

beginner

Write a simple example of a static method inside a Java interface.

public interface Calculator { static int add(int a, int b) { return a + b; } } You can call it with Calculator.add(5, 3); which returns 8.

How do you invoke a static method defined in a Java interface?

A Using the interface name, like InterfaceName.methodName()

B Using an instance of a class that implements the interface

C Using the class name that implements the interface

D Static methods cannot be defined in interfaces

Static methods in interfaces belong to the interface itself and are called using the interface name.

Can a class override a static method defined in an interface?

A No, static methods in interfaces cannot be overridden

B Yes, always

C Only if the class is abstract

D Only if the method is public

Static methods in interfaces belong to the interface and cannot be overridden by implementing classes.

When were static methods introduced in Java interfaces?

A Java 5

B Java 6

C Java 11

D Java 8

Static methods in interfaces were introduced in Java 8 to allow utility methods inside interfaces.

Which of the following is true about static methods in interfaces?

A They cannot have a method body

B They must be overridden by implementing classes

C They can be called without creating an instance

D They are abstract by default

Static methods belong to the interface and can be called directly without an instance.

What is a common use case for static methods in interfaces?

A To override default methods

B To provide utility/helper methods related to the interface

C To store instance variables

D To create constructors

Static methods in interfaces are often used for utility or helper methods related to the interface.

Explain what static methods in interfaces are and how they differ from instance methods.

Think about who owns the method and how you call it.

Describe why static methods were added to interfaces in Java 8 and give an example.

Consider code organization and convenience.

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