Master Java Interfaces: Default & Static Methods Explained with Real-World Examples

Many Java learners wonder what an interface actually is; even experienced developers find it hard to describe.

Interfaces act as communication protocols between modules, similar to hardware components that follow standardized slots on a motherboard.

In software, different vendors can produce interchangeable parts as long as they conform to a defined interface.

To illustrate, we define two interfaces, CPU and GraphicsCard, representing slots on a motherboard:

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

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

Implementations IntelCPU and NVIDIACard provide concrete behavior:

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 two interfaces and provides setter methods to “plug” the components:

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 Mainboard depends only on the interfaces, not on concrete implementations, allowing different developers to work independently.

Java 8 introduced default methods, enabling 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. A class can also invoke a default method from a specific interface using InterfaceName.super.method():

class Dog implements Animal {
    public void desc() {
        Animal.super.desc();
        System.out.println("狗");
    }
}

If a class implements multiple interfaces that define the same default method, the class must resolve the conflict either by overriding the method or by explicitly selecting one interface’s default implementation.

When an interface extends another and both define a default method with the same signature, the child interface’s version takes precedence. For example, interface B extends A and overrides print(); a class implementing both A and B will use B 's implementation.

Java 8 also allows static methods in interfaces. These methods belong to the interface itself and must be invoked via the interface name, not through implementing classes or sub‑interfaces:

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));
    }
}

Static methods cannot be inherited by implementing classes, and a static method cannot be declared as both static and default.