Interfaces Deep Dive

Default methods

A method in an interface that comes with a body.

public interface Deployable {
    boolean isDeployable();                       // abstract: implementers must supply this

    default String status() {                     // default: they get this free
        return isDeployable() ? "READY" : "HOLD";
    }
}

Existing classes inherit status() and keep compiling. New classes can override it if they want something better.

That is how forEach, removeIf, stream() and sort() were added to interfaces the whole world had already implemented. It is a compatibility feature that turned out to be generally useful.

Static methods in interfaces

Also since Java 8, an interface can hold static helper methods.

public interface Deployable {
    boolean isDeployable();

    static Deployable never() {
        return () -> false;
    }
}

Deployable d = Deployable.never();

Before this, helpers lived in a separate class named after the interface plus an “s”: Collection and Collections, Path and Paths. That naming convention exists entirely because interfaces could not hold static methods, and modern Java no longer needs it.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Java 8 added `forEach` to the `Collection` interface. Millions of classes already implemented it. Why did none of them break?

   Show the answer

   Because forEach was added as a default method: a method in an interface that comes with a body.

   Before Java 8, adding a method to an interface broke every implementation on earth, because each one now failed to implement something. That made widely used interfaces effectively frozen for ever.

   A default method supplies an implementation, so existing classes inherit it and keep compiling. Classes that want something better override it.

   This is why default methods exist. Not to make interfaces more like classes, but to let Java add lambdas and streams to collections without breaking the world. It was a compatibility feature that turned out to be generally useful.

2. A class implements two interfaces, and both have a default method with the same signature. What happens?

   Show the answer

   It does not compile. Java refuses to guess, and the error names both interfaces.

   This is the diamond problem from Section 7.1, arriving through a different door. Java avoided it for classes by allowing only one parent. Default methods reopened the possibility, so the language handles it by requiring you to decide.

   You resolve it by overriding the method and choosing explicitly:

   public void greet() { Formal.super.greet(); }

   Note the syntax: InterfaceName.super.method(). It exists only for this situation.

3. What makes an interface functional, and why does that one property matter so much?

   Show the answer

   Exactly one abstract method. Default and static methods do not count, because they already have bodies. So an interface can have twenty methods and still be functional, as long as nineteen of them are default or static.

   It matters because it removes ambiguity. When there is only one method left to implement, you no longer need to say which method you are implementing. And once the name is unnecessary, so is nearly everything else: the interface name comes from the parameter type, the parameter types are inferred, and the braces and return are ceremony.

   Delete all of it and what remains is a lambda. That is why every lambda in Java targets a functional interface, and why this single property is the doorway to all of Phase XI.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises110 pointsabout 120 minutes

interface Deployable {
    boolean isDeployable();
}

class GroundUnit implements Deployable {
    public boolean isDeployable() { return true; }
}

class AirUnit implements Deployable {
    public boolean isDeployable() { return false; }
}

class NavalUnit implements Deployable {
    public boolean isDeployable() { return true; }
}

public class Evolve {
    public static void main(String[] args) {
        Deployable[] units = { new GroundUnit(), new AirUnit(), new NavalUnit() };
        for (Deployable d : units) System.out.println(d.isDeployable());

        // TODO: add an abstract status() to the interface. What breaks?
        // TODO: now make it a default method instead. What changes?
        // TODO: override it in exactly one class and confirm the others keep the default
    }
}

interface Formal { default String greet() { return "Good evening"; } }
interface Casual { default String greet() { return "Hey"; } }

class Base    { public String greet() { return "from the class"; } }
interface Sub extends Formal { default String greet() { return "more specific"; } }

public class Diamond {
    // TODO 1: class A implements Formal, Casual   -> will not compile. Fix it.
    // TODO 2: class B extends Base implements Formal  -> which greet wins? Predict first.
    // TODO 3: class C implements Sub, Formal      -> which greet wins? Predict first.

    public static void main(String[] args) {
        // TODO: build one of each and print greet()
    }
}

import java.util.*;
import java.util.function.*;

@FunctionalInterface
interface Greeter { void greet(String name); }

public class FourWays {
    public static void main(String[] args) {
        // TODO 1: a named class implementing Greeter
        // TODO 2: an anonymous class
        // TODO 3: a lambda
        // TODO 4: a method reference

        // Then the same progression for sorting:
        List<String> units = new ArrayList<>(List.of("Cipher", "Atlas", "Drift", "Beacon"));
        // TODO 5: sort by length with an anonymous Comparator
        // TODO 6: the same sort with a lambda
        // TODO 7: the same sort with Comparator.comparingInt

        // TODO 8: add a second abstract method to Greeter. What error appears, and where?
    }
}

import java.util.*;
import java.util.function.*;

public class RegistryInterfaces {
    // TODO: interface Deployable
    //         boolean isDeployable();
    //         default String status()    -> READY or HOLD
    //         static Deployable never()  -> always false
    //
    // TODO: interface Auditable {}       - a marker. Some units get audited, some do not.
    //
    // TODO: @FunctionalInterface interface UnitFilter { boolean test(Unit u); }
    //
    // TODO: class Unit implements Deployable (and Auditable for some)
    //
    // TODO: static List<Unit> filter(List<Unit> units, UnitFilter f)
    //       then call it with lambdas: readiness above 60, active only, auditable only

    public static void main(String[] args) {
        // build a roster and run several filters through it
    }
}