Java interfaces and implementing multiple contracts

Interfaces

An interface defines a contract — a set of methods a class promises to implement. Unlike abstract classes, a class can implement many interfaces, enabling flexible composition across unrelated hierarchies.

Defining and Implementing

public interface Printable {
    void print();             // abstract method (implicitly public)

    default String format() { // default method (Java 8+)
        return "[Printable]";
    }
}

public interface Serializable {
    String serialize();
}

public class Report implements Printable, Serializable {
    private String content;

    public Report(String content) { this.content = content; }

    @Override
    public void print() {
        System.out.println(format() + " " + content);
    }

    @Override
    public String serialize() {
        return "{\"content\":\"" + content + "\"}";
    }
}

Report r = new Report("Q3 results");
r.print();            // [Printable] Q3 results
System.out.println(r.serialize()); // {"content":"Q3 results"}

Interface fields are implicitly public static final — constants. Interface methods are implicitly public abstract unless marked default or static.

Default methods let library authors add new methods to interfaces without breaking existing implementations. If two implemented interfaces define the same default method, the class must override it to resolve the ambiguity — the compiler enforces this.

Choose an interface when classes from unrelated hierarchies need a shared contract. Choose an abstract class when subclasses share state or substantial concrete implementation.