Interfaces as contracts between unrelated classes

Understanding Interfaces as contracts between unrelated classes

Java gives each class exactly one superclass, so two classes that genuinely have nothing in common, such as an email message and a temperature reading, cannot be given a shared parent without inventing a parent that lies about both of them. An interface sidesteps that by declaring only method signatures: interface Archivable { String archiveKey(); long sizeInBytes(); } says nothing about fields, constructors or ancestry, so a class anywhere in the hierarchy can promise those two methods. Once both classes carry implements Archivable they are interchangeable everywhere the surrounding code needs only those two operations, even though neither class knows the other exists.

The mental model is a promise checked in two stages. At compile time the reference type is all the compiler consults: inside a loop over List<Archivable> it confirms that archiveKey() is on the contract and rejects anything that is not, which is why the archiving code compiles without ever naming EmailMessage. At run time the JVM dispatches on the object's real class, so the body that executes belongs to whichever implementer happens to be in the list. That split is the payoff: an implementer written next year needs no edit and no recompile of the caller.

The compiler enforces the shape of the contract and never its meaning. Nothing stops sizeInBytes() from returning -1, so obligations like "the key is stable and unique" and "the size is never negative" live in the interface's documentation and are relied on by both sides. This is how the JDK joins hopelessly unrelated types: Comparable is implemented by String, BigDecimal and File, and Runnable by anything with work to do, purely because each one promises a single well-specified method.

import java.util.List;

interface Archivable {
    String archiveKey();
    long sizeInBytes();
}

class EmailMessage implements Archivable {
    private final String subject;
    private final String body;

    EmailMessage(String subject, String body) {
        this.subject = subject;
        this.body = body;
    }

    public String archiveKey() {
        return "mail/" + subject.toLowerCase().replace(' ', '-');
    }

    public long sizeInBytes() {
        return subject.length() + body.length();
    }
}

class SensorReading implements Archivable {
    private final int sensorId;
    private final double celsius;

    SensorReading(int sensorId, double celsius) {
        this.sensorId = sensorId;
        this.celsius = celsius;
    }

    public String archiveKey() {
        return "sensor/" + sensorId;
    }

    public long sizeInBytes() {
        return Integer.BYTES + Double.BYTES; // packed id + value
    }
}

public class Main {
    static long archiveAll(List<Archivable> items) {
        long total = 0;
        for (Archivable item : items) {
            System.out.println("storing " + item.archiveKey() + " (" + item.sizeInBytes() + " bytes)");
            total += item.sizeInBytes();
        }
        return total;
    }

    public static void main(String[] args) {
        List<Archivable> batch = List.of(
                new EmailMessage("Quarterly Report", "Numbers attached."),
                new SensorReading(7, 21.5),
                new EmailMessage("Lunch", "1pm?"));
        long total = archiveAll(batch);
        System.out.println("total " + total + " bytes");
    }
}

Worked examples

interface Validatable {
    boolean isValid();
}

class LegacyForm {
    protected final String raw;

    LegacyForm(String raw) {
        this.raw = raw;
    }
}

class SignupForm extends LegacyForm implements Validatable {
    SignupForm(String raw) {
        super(raw);
    }

    public boolean isValid() {
        return raw.contains("@");
    }
}

class Coordinate implements Validatable {
    private final double lat;
    private final double lon;

    Coordinate(double lat, double lon) {
        this.lat = lat;
        this.lon = lon;
    }

    public boolean isValid() {
        return Math.abs(lat) <= 90 && Math.abs(lon) <= 180;
    }
}

public class Main {
    static void report(Validatable v) {
        System.out.println(v.getClass().getSimpleName()
                + " extends " + v.getClass().getSuperclass().getSimpleName()
                + " -> valid=" + v.isValid());
    }

    public static void main(String[] args) {
        report(new SignupForm("ada@example.com"));
        report(new SignupForm("no-at-sign"));
        report(new Coordinate(48.85, 2.35));
        report(new Coordinate(120.0, 2.35));
    }
}

interface Playable {
    void play();
}

class Podcast implements Playable {
    public void play() {
        System.out.println("streaming episode 12");
    }

    void downloadTranscript() {
        System.out.println("saved transcript-12.txt");
    }
}

public class Main {
    public static void main(String[] args) {
        Playable item = new Podcast();
        item.play();
        // item.downloadTranscript(); // rejected at compile time: not on the contract
        if (item instanceof Podcast) {
            ((Podcast) item).downloadTranscript();
        }
        System.out.println(item.getClass().getSimpleName() + " held as " + Playable.class.getSimpleName());
    }
}

Important notes

Common mistakes

Try it yourself