Interfaces

Why interfaces?

Many unrelated classes may share one ability: an Invoice, a Report and a Ticket can all be exported as PDF; a Car and a Fan can both be switched on. They have no common parent, and Java allows only one superclass. An interface describes an ability (a contract) that any class can sign up to, in addition to its own class hierarchy.

public interface Exportable {
    byte[] toPdf();                           // abstract by default (public abstract)
    default String fileName() {               // default method (Java 8+): has a body
        return getClass().getSimpleName().toLowerCase() + ".pdf";
    }
    static boolean isPdf(String name) {       // static helper on the interface
        return name.endsWith(".pdf");
    }
}

public class Invoice implements Exportable, Comparable<Invoice> {
    private final double total;
    public Invoice(double total) { this.total = total; }
    @Override public byte[] toPdf() { return ("Invoice " + total).getBytes(); }
    @Override public int compareTo(Invoice o) { return Double.compare(total, o.total); }
}

Rules and features

• Interface methods without a body are implicitly public abstract; a class implementing the interface must implement them all (or be abstract).
• Fields in interfaces are implicitly public static final constants.
• A class can implement many interfaces: class Invoice implements Exportable, Comparable<Invoice>.
• An interface can extend other interfaces.
• default methods (Java 8) let interfaces add new methods without breaking existing implementations; private methods (Java 9) help share code between defaults.

Functional interfaces

An interface with exactly one abstract method is a functional interface, and you can implement it with a lambda (module 8). Comparator, Runnable and Predicate are examples. Mark your own with @FunctionalInterface so the compiler checks it.

@FunctionalInterface
interface DiscountRule { double apply(double price); }

DiscountRule festival = price -> price * 0.9;     // a lambda implements the single method
System.out.println(festival.apply(1000));          // 900.0

Abstract class versus interface

Programming to an interface

java.util.List<String> names = new java.util.ArrayList<>();   // variable typed by the interface
// later, switching to LinkedList means changing ONE line:
// java.util.List<String> names = new java.util.LinkedList<>();

Sealed interfaces (Java 17)

A sealed interface or class lists exactly which classes may implement or extend it: sealed interface Payment permits Upi, Card, Cod {}. The compiler then knows every possible case, so a switch over a Payment with case Upi u ->, case Card c -> and case Cod d -> needs no default (pattern matching for switch, Java 21). Each permitted class must be final, sealed or non-sealed.