Java Interfaces: Defining Contracts and implements

An Interface Is a Contract

An interface declares what a class can do without saying how. It is a list of method signatures that any implementing class promises to fulfill. The point is decoupling: code can work with the interface type and not care which concrete class is behind it.

interface Shape {
    double area();          // every Shape must provide an area
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

    Circle(double radius) { this.radius = radius; }

    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape means Circle must define area and perimeter. Once it does, a Circle is a Shape and can be stored in a Shape variable.

Many Classes, One Type

The power shows when several unrelated classes implement the same interface. Code written against Shape handles all of them:

import java.util.List;

interface Shape {
    double area();
}

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

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(2, 3), new Circle(2));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // works for every Shape, whatever its class
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

The loop never asks "is this a Circle or a Rectangle?" - it just calls area() and trusts the contract. Adding a Triangle later needs no change here.

Implementing Multiple Interfaces

A class extends only one class, but it can implement any number of interfaces - this is how Java does "multiple inheritance" of behavior safely:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

List the interfaces comma-separated after implements. The class must satisfy all of them.

default and static Methods

Since Java 8, an interface can ship method bodies. A default method gives implementing classes a ready-made implementation they inherit for free (and may override):

interface Greeter {
    String name();

    default String greet() {        // shared implementation
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() is inherited from the interface
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

default methods let an interface evolve - adding a method without breaking every existing implementer. A static interface method, by contrast, behaves like other static members: it is a utility you call on the interface itself, like Comparator.naturalOrder().

Constants

Fields in an interface are implicitly public static final - they are constants, not instance state:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

Interfaces traditionally hold no per-object state; the absence of instance fields is part of what distinguishes them from classes.

Functional Interfaces

An interface with exactly one abstract method is a functional interface, and you can implement it with a lambda expression instead of a whole class:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // lambda implements the single method
        System.out.println(doubler.apply(21));
    }
}

This is the foundation of Java's lambdas and the java.util.function types (Function, Predicate, Supplier, and friends). The @FunctionalInterface annotation makes the intent explicit and lets the compiler enforce the single-method rule.

Interface vs Abstract Class

Both let you program to an abstraction, so when do you pick which?

• Interface - a capability that unrelated classes can share. A Bird and an Airplane can both be Flyable. A class can implement many. No instance state.
• Abstract class - shared state and code among closely related classes. A Cat and a Dog both extend Animal, inheriting common fields and partially implemented methods. A class extends only one.

A common pattern combines them: an interface defines the contract, and an abstract class implements the boilerplate parts so concrete subclasses fill in only the specifics.

Next: Abstract Classes

Interfaces define behavior with no state. Abstract classes sit in between interfaces and full classes - they can declare unimplemented methods and carry fields and constructors. That is the next page.