What are default methods in Java interfaces and why were they introduced?

public interface Greeter {

    // Abstract method — must be implemented by every class
    String getName();

    // Default method — has a body; implementing class may override
    default String greet() {
        return "Hello, " + getName() + "!";
    }

    // Default method that calls another default method
    default String greetLoud() {
        return greet().toUpperCase();
    }
}

// Implementing class — inherits greet() without overriding
public class EnglishGreeter implements Greeter {
    @Override
    public String getName() { return "World"; }
}

// Implementing class — overrides greet()
public class FrenchGreeter implements Greeter {
    @Override
    public String getName() { return "Monde"; }

    @Override
    public String greet() {
        return "Bonjour, " + getName() + "!";
    }
}

// Usage
Greeter eng = new EnglishGreeter();
System.out.println(eng.greet());      // Hello, World!
System.out.println(eng.greetLoud());  // HELLO, WORLD!

Greeter fr = new FrenchGreeter();
System.out.println(fr.greet());       // Bonjour, Monde!

interface A {
    default String hello() { return "Hello from A"; }
}

interface B extends A {
    @Override
    default String hello() { return "Hello from B"; }  // more specific
}

interface C {
    default String hello() { return "Hello from C"; }
}

// Case 1: B is more specific than A — B wins
class D implements A, B {
    // no override needed; B.hello() wins automatically
}

// Case 2: B and C conflict — must override
class E implements B, C {
    @Override
    public String hello() {
        // Resolve manually — can call a specific interface's default:
        return B.super.hello();   // explicitly delegate to B
    }
}

System.out.println(new D().hello());  // Hello from B
System.out.println(new E().hello());  // Hello from B

public interface Logger {

    // Public default methods
    default void logInfo(String msg) {
        log("INFO", msg);
    }

    default void logError(String msg) {
        log("ERROR", msg);
    }

    // Private helper — shared by both defaults, NOT visible to implementors
    private void log(String level, String msg) {
        System.out.printf("[%s] %s%n", level, msg);
    }
}

public class AppService implements Logger {
    public void run() {
        logInfo("Service started");
        logError("Something went wrong");
    }
}
// AppService cannot call log() directly — it is private to Logger

public interface MathUtils {

    // Static interface method — utility / factory helper
    static int add(int a, int b) {
        return a + b;
    }

    static int square(int n) {
        return n * n;
    }
}

// Called via interface name — cannot be called on an implementing class instance
System.out.println(MathUtils.add(3, 4));     // 7
System.out.println(MathUtils.square(5));     // 25

// Real JDK example:
Comparator<String> natural = Comparator.naturalOrder();   // static method
Comparator<String> reversed = Comparator.reverseOrder();  // static method

public interface PaymentProcessor {

    // Abstract — every processor must implement
    boolean processPayment(double amount, String currency);

    // Default — common retry logic; processors may override
    default boolean processWithRetry(double amount, String currency) {
        int attempts = 0;
        while (attempts < 3) {
            log("Attempt " + (attempts + 1));
            if (processPayment(amount, currency)) return true;
            attempts++;
        }
        return false;
    }

    // Default — format amount for display
    default String formatAmount(double amount, String currency) {
        return String.format("%s %.2f", currency, amount);
    }

    // Private — shared logging helper
    private void log(String msg) {
        System.out.println("[PaymentProcessor] " + msg);
    }

    // Static factory
    static PaymentProcessor creditCard() {
        return (amount, currency) -> {
            System.out.println("Processing credit card: " + amount + " " + currency);
            return true;
        };
    }
}

// Implementation — only needs to implement processPayment
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public boolean processPayment(double amount, String currency) {
        System.out.println("PayPal: charging " + amount + " " + currency);
        return amount > 0;
    }
    // Inherits processWithRetry() and formatAmount() for free
}

// Usage
PaymentProcessor pp = new PayPalProcessor();
System.out.println(pp.formatAmount(99.99, "USD"));  // USD 99.99
pp.processWithRetry(99.99, "USD");

PaymentProcessor cc = PaymentProcessor.creditCard(); // static factory
cc.processPayment(50.00, "EUR");