What are default and static methods in interfaces?

• Default method has the default keyword and a method body. Implementing classes inherit it without overriding but can override if needed.
• Static method belongs to the interface itself. Called only via InterfaceName.method(). Not inherited by implementing classes.
• Backward compatibility was the primary motivation: Java 8 needed to add forEach(), stream(), removeIf(), and sort() to existing interfaces without breaking millions of implementations.
• Interface evolution means published APIs can add new methods without requiring every implementor to update their code.
• Polymorphism works with default methods: if an implementing class overrides a default, the overridden version is called.
• Key additions in Java 8: Iterable.forEach, Collection.stream, Collection.removeIf, List.sort, Map.getOrDefault, Map.computeIfAbsent.

What are default and static methods in interfaces?

Before Java 8, interfaces could only have abstract methods. Adding a new method to an existing interface broke every implementing class. Java 8 introduced default methods (methods with a body) and static methods (utility methods on the interface) to solve this problem.

Why were default methods added?

The Java team needed to add forEach(), stream(), and removeIf() to the Iterable and Collection interfaces. Without default methods, every ArrayList, LinkedList, HashSet, and TreeSet implementation worldwide would need updating. Default methods let them add these without modifying a single implementing class.

package com.bank.service;

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

public interface AccountService {
    BigDecimal getBalance(String accountId); // abstract: must implement

    // Default: inherited by all implementing classes for free
    default String getFormattedBalance(String accountId) {
        BigDecimal bal = getBalance(accountId);
        return "Rs." + bal.setScale(2, RoundingMode.HALF_UP);
    }

    // Default: can call abstract methods
    default boolean isOverdrawn(String accountId) {
        return getBalance(accountId).signum() < 0;
    }
}

How do implementing classes interact with default methods?

package com.bank.service;

import java.math.BigDecimal;

public class SavingsAccountService implements AccountService {
    @Override
    public BigDecimal getBalance(String accountId) {
        // Only implements the abstract method
        return new BigDecimal("125000.00");
    }
    // getFormattedBalance() and isOverdrawn() inherited for FREE
}

public class CurrentAccountService implements AccountService {
    @Override
    public BigDecimal getBalance(String accountId) {
        return new BigDecimal("450000.00");
    }

    @Override
    public String getFormattedBalance(String accountId) {
        // Custom override for business accounts
        return "Business Balance: Rs." + getBalance(accountId);
    }
}

What are static methods in interfaces?

package com.bank.service;

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

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

    // Static: utility on the interface, NOT inherited
    static BigDecimal roundToPaisa(BigDecimal amount) {
        return amount.setScale(2, RoundingMode.HALF_UP);
    }

    static InterestCalculator 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 = InterestCalculator.roundToPaisa(new BigDecimal("123.456"));

// WRONG: cannot call via implementing class
// SavingsInterest.roundToPaisa(...); // COMPILE ERROR! Not inherited!

How are default methods different from static methods?

| Aspect | Default Method | Static Method |
|--------|---------------|---------------|
| Keyword | default | static |
| Inherited | Yes | No |
| Can override | Yes | No |
| Called via | instance.method() | InterfaceName.method() |
| Purpose | Backward-compatible evolution | Utility/factory |
| Polymorphism | Yes (dynamic dispatch) | No (always interface version) |

What methods were added via default in Java 8?

Key methods added to existing interfaces without breaking implementations:

• Iterable.forEach(Consumer) : iterate with lambda
• Collection.stream() : create Stream
• Collection.removeIf(Predicate) : remove matching elements
• List.sort(Comparator) : sort in-place
• List.replaceAll(UnaryOperator) : transform each element
• Map.forEach(BiConsumer) : iterate key-value pairs
• Map.getOrDefault(key, default) : safe get
• Map.putIfAbsent(key, value) : conditional put
• Map.computeIfAbsent(key, Function) : lazy compute
• Comparator.thenComparing() : multi-key sort

What are the limitations of default methods?

Default methods cannot access instance state because interfaces have no fields (except static final constants). They can only call other methods on the interface, including abstract methods that the implementing class provides. If two interfaces define the same default method, the implementing class must override to resolve the conflict.

What should a senior engineer know?

Default methods are the foundation of Java's interface evolution strategy. They enabled the entire Stream API and functional programming additions without breaking backward compatibility. The pattern continues in later versions: Java 9 added List.of(), Set.of(), Map.of() as static factory methods on the collection interfaces themselves.