Default, Static and Private Interface Methods

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Default method

An interface method with a body, marked default. Implementing classes get it automatically and may override it.

Static interface method

A method with a body, marked static, that belongs to the interface. Call it through the interface name.

Private interface method

A helper method inside an interface (Java 9+), usable only by the interface's own default, static and private methods.

Interface evolution

Adding new methods to an interface that is already in use without breaking existing implementations.

Binary compatibility

Old compiled .class files keep working with a new version of a library, without being recompiled.

X.super.m()

Syntax to call interface X's default m() from a class or interface that directly implements or extends X.

Diamond problem

When a class gets the same method from two parents and it's unclear which one to use.

1. 1

   Remove the override in SmartPhone

   In the conflict-rules example, delete SmartPhone's start() method and compile. Read the 'unrelated defaults' error. Then make it return only Phone.super.start() and run.

2. 2

   Try calling a private helper from outside

   In the Report example, add String test() { return frame("x"); } to SalesReport. The compiler says cannot find symbol: the private method is invisible outside the interface.

3. 3

   Try a default toString

   Add default String toString() { return title(); } to Report and compile. Read the error and explain it using rule 1.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

interface A { default String hello() { return "A"; } }
interface B { default String hello() { return "B"; } }
class C implements A, B { }

interface Util { static int twice(int x) { return 2 * x; } }
class Impl implements Util { }
public class Main { public static void main(String[] a) { System.out.println(new Impl().twice(2)); } }

interface Named { default String toString() { return "x"; } }

1. 1

   A default method is an interface method with a body, marked default: default String describe() { return "area " + area(); }. Every implementing class inherits it automatically and may override it. A default method can call the interface's abstract methods, because the object it runs on is always a real implementation.

2. 2

   Default methods exist mainly for interface evolution. Before Java 8, adding a method to Collection would have broken every collection class ever written. Java 8 added Iterable.forEach, Collection.stream, Collection.removeIf, List.sort and Map.getOrDefault as defaults, so all existing classes got them for free.

3. 3

   If a class inherits the same default method from two places, three rules decide: (1) a class wins: a method from the superclass chain beats any interface default; (2) the more specific interface wins: if B extends A and both define it, B's version is used; (3) otherwise it's a conflict and the class must override the method, optionally calling one parent with A.super.method().

4. 4

   A static interface method belongs to the interface itself: call it as Comparator.naturalOrder() or List.of(1, 2). Unlike static methods in classes, it is not inherited by implementing classes or sub-interfaces, so myComparator.naturalOrder() doesn't compile.

5. 5

   A private interface method (Java 9) is a helper visible only inside the interface. Use it to share code between default methods without exposing that code as part of the public contract. private static methods are allowed too, for helpers used by static methods.

6. 6

   Defaults still can't hold state (no instance fields), can't be final or synchronized, and can't override equals, hashCode or toString from Object (rule 1 means Object's version would always win, so the compiler forbids it).

• ↔

  Defaults let you add behaviour to an interface cheaply, but each one becomes part of every implementer's API forever, and implementers inherit behaviour they never reviewed. Add defaults that are obviously correct for every implementation, or document them with @implSpec.

• ↔

  Static factories on interfaces (List.of) keep creation next to the type, but they can only return types visible to the interface. Hidden implementation classes need to be package-private classes or private nested classes.

• Done when you can add a default method to an interface and override it in one implementation.

• Done when you can apply the three conflict rules and use X.super.m().

• Done when you can call static interface methods correctly and know they aren't inherited.

• Done when you can use private interface methods (Java 9) to share code between defaults.

• Done when you can name JDK default methods like List.sort and Map.getOrDefault.