Interfaces as contracts

Written Explanation

What an interface is

An interface is a type that lists methods without bodies. It is a contract: any class that signs it must provide every listed method.

interface Shape {
    double area();
}

There is no { ... } after area(), only a semicolon. That line says: "a Shape is anything that can report its area as a double". It does not say how to compute it.

A class signs the contract with implements and then writes each method:

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    @Override public double area() { return Math.PI * r * r; }
}

Use @Override here for the same reason as in the last module: the compiler checks that the method really implements something from the interface.

The Java tutorial describes interfaces as contracts: implementers may change their internals freely as long as they keep the published methods, and callers can be written against the interface without knowing the implementation.

The compiler enforces the contract

If a class says implements Shape but does not write area(), the code does not compile. Compare this with the empty-body default from the previous module: there, forgetting an override compiled and ran silently. Here, forgetting is impossible.

An interface is a type

You cannot write new Shape(): an interface has no code to run, so there is nothing to build. But you can use it as a type:

Shape[] shapes = { new Circle(1), new Rect(2, 3) };
for (Shape s : shapes) System.out.println(s.area());

A Shape variable can refer to any object whose class implements Shape. This is the same upcasting you met in the polymorphism module, now with an interface on the left. The call s.area() runs whichever version the real object has. Through a Shape variable you can call only the methods that Shape declares.

Rules for what is inside an interface

Per the Java Language Specification, a method with no access modifier in an interface is public, and a field is public static final. The consequence you will meet first: when a class implements the method it must also write public, because a class method without a modifier is package-private, and that is weaker access than the interface promised.

Many interfaces, one parent class

A class can extend only one class, but it can implement any number of interfaces, separated by commas:

class SmsNotifier implements Notifier, Auditable { ... }

This is how Java lets one class play several roles without the tangles that come from inheriting state from several parents. Interfaces carry no instance state, so there is nothing to clash.

Naming and size

Name an interface after the role: Shape, Notifier, Payable. Keep it small and focused. An interface with one clear job is easy to implement and easy to fake in a test. An interface with ten unrelated methods (a "god" interface) forces every class to write methods it does not want. Tests and callers also become harder to read.

Where the analogy stops

A wall socket fixes the shape of the plug but not the safety of the device. An interface fixes the method signatures, but not what the methods do. A class can implement send by doing nothing at all. Meaning is documented in comments and checked by tests, not by the compiler.