Interfaces in Java

Interface Members

Every field declared in an interface is implicitly public static final, whether or not you write those modifiers — interfaces cannot hold per-instance state. Methods without a body are implicitly public abstract.

• Abstract methods — no body; any implementing class must provide one.
• Default methods — declared with the default keyword and a body, providing a fallback implementation that implementing classes may override.
• Static methods — declared with static and called on the interface itself, e.g. Comparator.naturalOrder().
• Constants — fields are always public static final automatically.

Implementing Multiple Interfaces

Java classes can only extend one superclass, but they can implement any number of interfaces, separated by commas: class Duck implements Flyable, Swimmable. This is how Java achieves a safe form of "multiple inheritance of type" without the ambiguity problems C++ faces with multiple inheritance of implementation.

Default Methods and Diamond Conflicts

If a class implements two interfaces that each declare a default method with the same signature, the compiler forces the class to override that method explicitly and resolve the conflict — it will not guess which default to use. This keeps default methods from silently reintroducing the classic diamond problem.

Example

interface Vehicle {
    int MAX_SPEED = 180; // implicitly public static final

    void start(); // implicitly public abstract

    default void honk() {
        System.out.println("Beep beep!");
    }

    static Vehicle basic() {
        return () -> System.out.println("Basic vehicle starting");
    }
}

public class InterfaceDemo implements Vehicle {
    @Override
    public void start() {
        System.out.println("Vehicle starting, max speed " + MAX_SPEED);
    }

    public static void main(String[] args) {
        InterfaceDemo v = new InterfaceDemo();
        v.start();
        v.honk();
        Vehicle.basic().start();
    }
}

Vehicle starting, max speed 180
Beep beep!
Basic vehicle starting

Exercise

Define an interface Payable with an abstract method amount() and a default method receipt() that returns "Paid " followed by the amount. Then write an Invoice class that implements it.

Expected output: Paid 1200

// TODO: interface Payable with int amount() and a default String receipt()

// TODO: class Invoice implements Payable, constructed with a total

public class PayableDemo {
    public static void main(String[] args) {
        Payable invoice = new Invoice(1200);
        System.out.println(invoice.receipt());
    }
}

interface Payable {
    int amount();

    default String receipt() {
        return "Paid " + amount();
    }
}

class Invoice implements Payable {
    private final int total;

    Invoice(int total) {
        this.total = total;
    }

    @Override
    public int amount() {
        return total;
    }
}

public class PayableDemo {
    public static void main(String[] args) {
        Payable invoice = new Invoice(1200);
        System.out.println(invoice.receipt()); // Paid 1200
    }
}

Quick quiz

Interview questions