Mastering Java Interfaces: From Basic Contracts to Default & Static Methods

Many Java learners wonder what an interface really is. An interface serves as a communication protocol between modules, similar to how hardware components use standardized slots to connect.

Just as a computer is assembled from a motherboard, CPU, graphics card, and memory produced by different manufacturers, software modules can be assembled by defining interfaces that specify required methods.

We define two interfaces, CPU and GraphicsCard, to represent the slots on a motherboard:

package computer;
public interface CPU {
    void calculate();
}

package computer;
public interface GraphicsCard {
    void display();
}

Implementations of these interfaces are provided by different vendors:

package computer;
public class IntelCPU implements CPU {
    public void calculate() {
        System.out.println("Intel CPU calculate.");
    }
}

package computer;
public class NVIDIACard implements GraphicsCard {
    public void display() {
        System.out.println("Display something");
    }
}

The Mainboard class holds references to the interfaces, not the concrete classes, and invokes their methods without knowing the actual implementations:

package computer;
public class Mainboard {
    private CPU cpu;
    private GraphicsCard gCard;

    public void setCpu(CPU cpu) { this.cpu = cpu; }
    public void setGraphicsCard(GraphicsCard gCard) { this.gCard = gCard; }

    public void run() {
        System.out.println("Starting computer...");
        cpu.calculate();
        gCard.display();
    }
}

The Computer class assembles everything:

package computer;
public class Computer {
    public static void main(String[] args) {
        Mainboard mb = new Mainboard();
        mb.setCpu(new IntelCPU());
        mb.setGraphicsCard(new NVIDIACard());
        mb.run();
    }
}

This example shows that the Mainboard only depends on the contract (the interfaces), not on specific implementations, enabling independent development of each module.

Java 8 introduced default methods, allowing interfaces to provide method bodies without breaking existing implementations. For example:

public interface Animal {
    void bark();
    void move();
    default void desc() {
        System.out.println("动物");
    }
    default String getName() {
        return "unknown";
    }
}

Implementing classes can inherit these defaults or override them. Overriding a default method does not require re‑implementing the whole interface.

When a class implements multiple interfaces that define the same default method, the compiler requires the class to resolve the conflict either by overriding the method or by explicitly invoking a specific interface’s default implementation using InterfaceName.super.method(). For instance:

class Dog implements Animal {
    public void desc() {
        Animal.super.desc(); // call Animal's default
        System.out.println("狗");
    }
}

If two interfaces provide a method with the same signature, the most specific (sub‑interface) default wins. Example:

interface A {
    default void print() { System.out.println("A"); }
}
interface B extends A {
    default void print() { System.out.println("B"); }
}
public class InterfaceDefaultMethod implements A, B {
    public static void main(String[] args) {
        new InterfaceDefaultMethod().print(); // prints "B"
    }
}

If the conflict comes from unrelated interfaces (both inherit the same default from a common parent), the implementing class must provide its own implementation to break the ambiguity.

Java 8 also allows static methods in interfaces, which are accessed only through the interface name:

interface Math {
    static int add(int a, int b) { return a + b; }
}
public class InterfaceStaticMethod {
    public static void main(String[] args) {
        System.out.println("5 + 3 = " + Math.add(5, 3));
    }
}

Attempting to call the static method via the implementing class (e.g., InterfaceStaticMethod.add()) results in a compilation error, demonstrating that static interface methods are not inherited.

These features—default and static methods—enhance interface evolution while preserving backward compatibility, but they also introduce new design considerations for multiple inheritance and method resolution.