Understanding Java Interfaces: Protocols, Default and Static Methods

Many Java beginners wonder what an interface actually is; this article treats interfaces as the protocol that enables communication between modules, similar to hardware slots that allow different components to be assembled together.

Using a computer‑assembly analogy, the motherboard provides slots (interfaces) for a CPU and a graphics card. The CPU and GraphicsCard interfaces declare the methods each component must implement.

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

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

Concrete classes IntelCPU and NVIDIACard implement these interfaces, providing the actual 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 CPU and GraphicsCard and invokes their methods without depending on concrete 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 the system by creating an Mainboard , injecting an IntelCPU and an NVIDIACard , and starting the run method.

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

Java 8 introduced default methods, allowing interfaces to provide method implementations without breaking existing implementors. An example Animal interface shows abstract methods bark and move together with default methods desc() and getName() .

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, as demonstrated with Dog and Cat . When a class implements multiple interfaces that define the same default method (e.g., Animal and Flyable both define desc() ), the class must resolve the conflict either by providing its own implementation or by explicitly invoking a specific interface’s default method using InterfaceName.super.method() .

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

Interface inheritance also affects default method selection: if interface B extends A and both define a default print() , the implementation of B takes precedence.

interface A { default void print() { System.out.println("A"); } }
interface B extends A { default void print() { System.out.println("B"); } }
class InterfaceDefaultMethod implements A, B { }
// Calling print() on an instance prints "B"

Static methods were also added to interfaces. They are public by default, must have a body, and can only be called through the interface name, not via implementing classes or sub‑interfaces.

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

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

Overall, the article demonstrates how interfaces define contracts, how default and static methods enhance interface evolution, and how Java resolves method conflicts, providing practical code examples for each concept.