Nested Interfaces in Java

A nested interface is an interface declared inside a class or inside another interface, rather than as its own top-level file. Java allows this because interfaces, like classes, can be members of another type. Nested interfaces are a common pattern for grouping a helper interface tightly with the one class (or interface) that logically owns it.

Why it matters

A nested interface is an interface declared inside a class or another interface, used when it only makes sense in that context. You use one every time you loop over a map: Map.Entry. The same pattern appears in callback and listener APIs, so recognising the Outer.Inner name is part of reading library code.

Why Nest an Interface

Nesting communicates intent: "this interface only makes sense in the context of its enclosing type." A frequent real example is a listener or callback interface — a class that fires events defines a nested interface describing how outsiders should react to those events, keeping the contract physically next to the class that uses it. This avoids cluttering the package with small, tightly-coupled interfaces that are meaningless anywhere else.

Rules for Nested Interfaces

A nested interface is implicitly static when declared inside a class (even without writing the keyword), meaning it does not depend on any instance of the enclosing class to be referenced or implemented. It can carry any access modifier (public, protected, default, private since Java 9 for interface members) that a regular class member can. It is referenced from outside using the enclosing type's name as a qualifier.

• Declared inside a class: OuterClass.NestedInterface is how you refer to it from elsewhere.
• Declared inside another interface: it behaves the same way, qualified by the enclosing interface's name.
• A class can implement a nested interface just like any top-level interface: class Impl implements OuterClass.NestedInterface { ... }.

Example

class Button {

    // Nested interface: tightly coupled to Button, only meaningful here
    interface ClickListener {
        void onClick(String buttonName);
    }

    private String name;
    private ClickListener listener;

    Button(String name) {
        this.name = name;
    }

    void setClickListener(ClickListener listener) {
        this.listener = listener;
    }

    void simulateClick() {
        if (listener != null) {
            listener.onClick(name);
        }
    }
}

public class NestedInterfaceDemo implements Button.ClickListener {

    @Override
    public void onClick(String buttonName) {
        System.out.println(buttonName + " was clicked!");
    }

    public static void main(String[] args) {
        Button submitButton = new Button("Submit");
        NestedInterfaceDemo handler = new NestedInterfaceDemo();

        submitButton.setClickListener(handler);   // referenced via Button.ClickListener
        submitButton.simulateClick();
    }
}

Submit was clicked!

Exercise

Loop over the entries of the map and print each one as key=value, using the nested interface Map.Entry.

Expected output: apple=3 then banana=5

import java.util.Map;
import java.util.TreeMap;

public class EntryLoop {
    public static void main(String[] args) {
        Map<String, Integer> stock = new TreeMap<>();
        stock.put("banana", 5);
        stock.put("apple", 3);

        // TODO: loop over stock.entrySet() and print key=value for each entry
    }
}

import java.util.Map;
import java.util.TreeMap;

public class EntryLoop {
    public static void main(String[] args) {
        Map<String, Integer> stock = new TreeMap<>();
        stock.put("banana", 5);
        stock.put("apple", 3);

        for (Map.Entry<String, Integer> entry : stock.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
    }
}

Quick quiz

Interview questions