How are static methods in interfaces called?

• Calling: static methods on interfaces are called exclusively via InterfaceName.method(), never via an implementing class or an instance reference.
• Not inherited: if AccountService has a static method, SavingsAccountServiceImpl.method() does not compile.
• Not overridable: a class can define a method with the same name, but it is a completely separate method, not an override.
• Replaces utility classes: instead of Collections.sort() (utility class) and Collection (interface), Java 8 puts Comparator.comparing() and Predicate.not() directly on the interface.
• Factory methods: List.of(), Map.of(), Set.of() (Java 9) are static methods on collection interfaces.
• Keeps logic together: related functionality lives on the interface instead of being scattered across utility classes.

How are static methods in interfaces called?

Static methods in interfaces were added in Java 8. They belong to the interface namespace and are not part of the implementing class's API.

What is the syntax and calling convention?

package com.bank.service;

import java.math.BigDecimal;
import java.math.RoundingMode;

public interface InterestService {
    BigDecimal calculate(BigDecimal principal, int months);

    // Static: belongs to the INTERFACE
    static BigDecimal roundToPaisa(BigDecimal amount) {
        return amount.setScale(2, RoundingMode.HALF_UP);
    }

    static InterestService simpleInterest(BigDecimal annualRate) {
        return (principal, months) -> principal
            .multiply(annualRate)
            .multiply(BigDecimal.valueOf(months))
            .divide(BigDecimal.valueOf(12), 2, RoundingMode.HALF_UP);
    }
}

// CORRECT: called via InterfaceName
BigDecimal rounded = InterestService.roundToPaisa(new BigDecimal("123.456"));
System.out.println(rounded); // 123.46

// WRONG: cannot call via implementing class
// class FDInterestService implements InterestService { ... }
// FDInterestService.roundToPaisa(...); // COMPILE ERROR!

// WRONG: cannot call via instance
// FDInterestService fd = new FDInterestService();
// fd.roundToPaisa(...); // COMPILE ERROR!

Why are static methods not inherited?

package com.bank.core;

import java.math.BigDecimal;

interface Taxable {
    static BigDecimal gstRate() { return new BigDecimal("0.18"); }
}

class BrokerageService implements Taxable { }

public class StaticNotInherited {
    public static void main(String[] args) {
        // BrokerageService.gstRate(); // COMPILE ERROR: cannot find symbol
        System.out.println(Taxable.gstRate()); // Works: 0.18
    }
}

0.18

Can static methods be overridden?

No. A class can define a method with the same name, but it is a completely separate method. The @Override annotation produces a compile error.

package com.bank.core;

import java.math.BigDecimal;

interface Taxable {
    static BigDecimal gstRate() { return new BigDecimal("0.18"); }
}

class BrokerageService implements Taxable {
    // NOT an override: separate static method on the class
    // @Override // COMPILE ERROR if you try!
    static BigDecimal gstRate() { return new BigDecimal("0.12"); }
}

public class StaticNotOverridden {
    public static void main(String[] args) {
        System.out.println(Taxable.gstRate());          // 0.18 (interface)
        System.out.println(BrokerageService.gstRate()); // 0.12 (class's own)
    }
}

0.18
0.12

How did this change the standard library?

| Before Java 8 | After Java 8+ |
|---------------|---------------|
| Collections.sort(list) | list.sort(comparator) (default) |
| Collections.unmodifiableList(list) | List.of(elements) (static, Java 9) |
| Manual Comparator creation | Comparator.comparing(Account::balance) (static) |
| Custom utility class | Predicate.not(Account::isDormant) (static) |

What are common use cases?

Factory methods like List.of(), Map.of(), and Set.of(). Utility functions like Comparator.comparing(), Predicate.not(), and Comparator.naturalOrder(). Constants like Taxable.gstRate(). Validation like AccountValidator.isValidIFSC(String code).

What are the rules and constraints?

Static methods cannot call instance methods or default methods on the interface because there is no instance. They can only use their parameters and other static methods. They cannot reference this or super.

What should a senior engineer know?

The pattern of putting static factory methods on interfaces continues to grow in Java. Java 9 added List.of(), Set.of(), Map.of(). Java 16 added Stream.toList(). This keeps related functionality together and eliminates the need for companion utility classes. In API design, prefer interface static methods over separate utility classes when the functionality is conceptually tied to the interface.