Java Interfaces: Functional, Default, Static and Private Methods (1Z0-831)

An interface is a reference type that declares a contract: every abstract method in it is implicitly public abstract, every field is implicitly public static final, and a class takes on the contract with implements. Because the methods are public, any class method that implements one must also be declared public. Leaving the modifier off is the classic trap: a blank modifier means public inside an interface but package access inside a class, so the class would be weakening access and the compiler rejects it with area() in Circle cannot implement area() in Shape (as it would if Circle below declared plain double area()).

A class that implements an interface must provide every abstract method or be declared abstract itself. An abstract class may implement an interface partially: it does not have to redeclare the methods it leaves out, and the first concrete subclass must supply whatever is still missing.

interface Shape {
    double PI_ISH = 3.0;      // public static final

    double area();            // public abstract

    String name();            // public abstract
}

abstract class NamedShape implements Shape {
    public String name() {
        return "circle";
    }
}

class Circle extends NamedShape {
    private final double r;

    Circle(double r) {
        this.r = r;
    }

    public double area() {
        return PI_ISH * r * r;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2);
        System.out.println(s.name() + " " + s.area());
    }
}

This prints circle 12.0. NamedShape supplies only name(); Circle finishes the contract with area(). A class may implement any number of interfaces, and an interface may extends any number of other interfaces (an interface never implements anything). Sealed interfaces (sealed … permits) follow the same member rules and are covered in the lesson on inheritance and sealed types.

Every field declared in an interface is a constant: implicitly public static final, so it must be initialized where it is declared and can never be assigned again. Implementing classes (and sub-interfaces) inherit the constant, so all of these read the same value: Limits.MAX, Box.MAX, a plain MAX inside the implementing class, and even b.MAX or this.MAX through a reference (legal, though style guides discourage reading statics through an instance).

Reading is always fine; writing never compiles. Any assignment, compound assignment or increment, written as MAX = 20, this.MAX = 20, Limits.MAX++ or MAX += 1, fails with cannot assign a value to static final variable MAX. A declaration without an initializer, such as int size;, is rejected too (= expected), because a blank final static field has nowhere else to be assigned.

final freezes the reference, not the object it points to. Because the field is static, there is exactly one of it for the whole program, shared by every implementing class and every instance:

import java.util.ArrayList;
import java.util.List;

interface Registry {
    List<String> NAMES = new ArrayList<>();

    default void register(String n) {
        NAMES.add(n);
    }
}

class Alpha implements Registry { }

class Beta implements Registry { }

public class Main {
    public static void main(String[] args) {
        new Alpha().register("a");
        new Beta().register("b");
        System.out.println(Registry.NAMES + " " + Alpha.NAMES.size());
    }
}

This prints [a, b] 2. Alpha and Beta add to the same list, because there is only one NAMES. Replacing the list (NAMES = new ArrayList<>()) would not compile, but changing its contents, or the elements of a final array, is allowed.

An interface may contain constants, abstract methods, default methods, static methods, private and private static methods, and nested types (classes, interfaces, enums, records). Everything except the private methods is public: there are no protected or package-access members in an interface. Each method kind takes a fixed set of modifiers, and the compiler checks them strictly (all verified with javac 25):

Two rules explain most of the table. Only abstract methods may lack a body, and abstract methods cannot be private, static or final. And an interface may not supply a default implementation of equals, hashCode or toString, because every object already inherits those from Object and a class method always beats a default, so such a default could never run. Redeclaring them abstract (boolean equals(Object o);) is legal.

A default method is a public instance method with a body, declared in an interface and inherited by every implementing class that does not override it. A default method may call the interface's abstract methods; at run time those calls dispatch to the implementing object's code, which makes defaults a natural place for template behaviour.

A class overrides a default like any other public method (it must be public). Inside the override it can still reach the interface's version with InterfaceName.super.method():

interface Report {
    String body();

    default String render() {
        return "<" + body() + ">";
    }
}

class Invoice implements Report {
    public String body() {
        return "inv";
    }

    public String render() {
        return Report.super.render().toUpperCase();
    }
}

public class Main {
    public static void main(String[] args) {
        Report r = new Invoice();
        System.out.println(r.render());
    }
}

This prints <INV>: the inherited default builds <inv> by calling Invoice.body(), and the override upper-cases it. Three forms do not work for reaching a default:

• super.render() refers to the superclass (here Object), so it fails with cannot find symbol.
• Report.render() is the syntax for a static call, and render() is an instance method, so it fails with a non-static-reference error.
• X.super.m() works only when X is a direct superinterface of the class or interface writing it. If P extends G and class C implements P, then inside C the call G.super.g() fails with not an enclosing class: G; you can call P.super.g(), and P's default may in turn call G.super.g().

A sub-interface can override a parent's default with a new default, or re-abstract it by redeclaring the method without a body, which forces implementers to supply it again.

When a class inherits more than one implementation of the same method signature, Java picks one using three rules, applied in order:

1. Classes win. A method inherited from a superclass (or declared in the class itself) takes priority over any interface default. This holds even when the superclass method is abstract: the default does not fill the gap, and a concrete class must implement the method itself.
2. The more specific interface wins. If interface Dog extends Animal and both declare the method, Dog's version overrides Animal's, so a class implementing both gets Dog's with no conflict. This also applies when the more specific interface re-abstracts the method: re-listing the parent interface in implements does not bring its default back.
3. Otherwise the class must override. Two unrelated interfaces with the same default signature make the class fail to compile (types Walker and Swimmer are incompatible) until it declares its own public version, which may call either or both with X.super.method().

interface Walker {
    default String move() {
        return "walk";
    }
}

interface Swimmer {
    default String move() {
        return "swim";
    }
}

class Duck implements Walker, Swimmer {
    public String move() {
        return Walker.super.move() + "+" + Swimmer.super.move();
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Duck().move());
    }
}

This prints walk+swim. Casting this to one interface does not select its default: ((Walker) this).move() is still a virtual call on a Duck, so it re-enters Duck.move() and recurses until a StackOverflowError.

Rule 1 in action, where an inherited class method beats the default even though the class itself declares nothing:

interface Start {
    default String go() {
        return "start";
    }
}

class Engine {
    public String go() {
        return "engine";
    }
}

class Car extends Engine implements Start { }

public class Main {
    public static void main(String[] args) {
        Start s = new Car();
        System.out.println(s.go());
    }
}

This prints engine. Change Engine.go() to public abstract String go(); (and make Engine abstract) and Car no longer compiles: Car is not abstract and does not override abstract method go() in Engine. A re-abstracting sub-interface produces the same kind of error, naming the sub-interface.

A static interface method belongs to the interface alone and is not inherited by implementing classes or by sub-interfaces. The only way to call it is InterfaceName.method(). This differs from static methods of a class, which subclasses do inherit:

• An unqualified call such as zone() inside an implementing class fails with cannot find symbol, even though the class implements the interface.
• Wall.zone(), new Wall().zone() and Sub.zone() (for interface Sub extends Clock) also fail with cannot find symbol.
• Clock.super.zone() fails with illegal static interface method call; X.super is only for default methods.

Inside the interface itself, its own static and default methods can call the static method unqualified. Because the method is never inherited, an implementing class may declare a static method with the same signature: it is an unrelated method, neither an override nor a hide.

interface Clock {
    static String zone() {
        return "UTC";
    }
}

class Wall implements Clock {
    static String zone() {          // unrelated method, not an override
        return "local";
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Clock.zone() + " " + Wall.zone());
    }
}

This prints UTC local. Each name selects its own method; the reference type of a variable never matters for a static call.

Private interface methods are helpers with a body that code inside the interface can share, without becoming part of its public API. They are never inherited, so implementing classes cannot call them (cannot find symbol). Which interface methods may call a helper depends on whether it is static:

This is the same instance/static rule as in classes: a private instance method needs an object to run on, and static code has none. The same goes for default methods: a default method is an instance method too, so a static interface method cannot call one either. When a static interface method needs a helper, make the helper private static (or static, if it may be public):

interface Money {
    static String format(int cents) {
        return cents / 100 + "." + pad(cents % 100);
    }

    default String show() {
        return label() + format(amount());
    }

    int amount();

    private String label() {
        return "$";
    }

    private static String pad(int n) {
        return n < 10 ? "0" + n : "" + n;
    }
}

public class Main {
    public static void main(String[] args) {
        Money m = () -> 1205;
        System.out.println(m.show() + " " + Money.format(7));
    }
}

This prints $12.05 0.07. The default method show() uses both helpers; the static format can use only the static one. private cannot be combined with default, abstract or final, and a private method must have a body.

A functional interface is an interface with exactly one abstract method once everything it inherits is taken into account; it is the only kind of type a lambda expression or method reference can target. To decide, count the abstract methods with these rules:

• default, static and private methods never count: they have bodies.
• Abstract methods inherited from superinterfaces do count. An interface that extends Runnable and adds void stop(); has two and is not functional; one that extends Runnable and adds only defaults is.
• An abstract method with the same signature as a public method of Object (boolean equals(Object), int hashCode(), String toString()) does not count, because every implementation already has one from Object.
• Object clone() does count: Object.clone() is protected, so a public abstract clone() in an interface is a real obligation. interface T { Object clone(); void run(); } has two abstract methods.
• Methods that are override-equivalent (the same signature after generic type substitution) count once. Redeclaring an inherited abstract method adds nothing.
• Zero abstract methods is not functional either: an interface that only redeclares equals, hashCode and toString cannot be a lambda target.

interface Supplier2<T> {
    T get();
}

interface Name extends Supplier2<String> {
    String get();                     // same method, not a second one

    boolean equals(Object o);         // public Object method: free

    default String shout() {
        return get().toUpperCase();
    }
}

public class Main {
    public static void main(String[] args) {
        Name n = () -> "duke";
        System.out.println(n.shout());
    }
}

This prints DUKE. Name has one abstract method: its get() is the same method as Supplier2<String>.get(), equals is free, and shout() has a body. The lambda implements get(), and the inherited default runs on top of it. The JDK's ready-made functional interfaces (java.util.function) and lambda syntax are covered with streams and lambdas in Section 6.

@FunctionalInterface asks the compiler to verify that an interface is functional; it does not create the property. Any interface with exactly one abstract method is functional, annotated or not, and can be a lambda target either way.

• Put the annotation on an interface with zero or more than one abstract method (counting inherited ones) and the interface itself fails to compile: Unexpected @FunctionalInterface annotation. The error is reported at the annotated interface even if nothing in the program uses it as a lambda target.
• Removing the annotation never makes a two-method interface usable by a lambda. The error just moves to the lambda: incompatible types: Checker is not a functional interface.
• The fix is to leave one abstract method: give the extra one a body as a default or static method, or delete it. Changing its parameter type (check(Object) instead of check(String)) only creates a different abstract method, so the count stays two.
• The annotation is not inherited. A sub-interface is checked only if it carries the annotation itself, and an annotated sub-interface that adds a second abstract method fails to compile even though its parent is a valid functional interface.

Use the annotation on interfaces meant for lambdas: it documents intent and stops someone from later adding a second abstract method, which would break every lambda that targets the interface.