Интерфейсы в Java: определение контрактов и implements

Интерфейс — это контракт

Интерфейс объявляет, что класс может делать, не говоря, как. Это список сигнатур методов, которые любой реализующий класс обязуется выполнить. Суть в развязке: код может работать с типом интерфейса и не заботиться о том, какой конкретный класс стоит за ним.

interface Shape {
    double area();          // каждая Shape должна предоставлять 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 означает, что Circle должен определить area и perimeter. Как только он это делает, Circle является Shape и может храниться в переменной типа Shape.

Много классов, один тип

Сила проявляется, когда несколько несвязанных классов реализуют один и тот же интерфейс. Код, написанный под Shape, обрабатывает их все:

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();   // работает для любой Shape, какого бы класса она ни была
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Цикл никогда не спрашивает «это Circle или Rectangle?» — он просто вызывает area() и доверяет контракту. Добавление Triangle позже не потребует здесь никаких изменений.

Реализация нескольких интерфейсов

Класс наследует только один класс, но может реализовывать любое число интерфейсов — именно так Java безопасно осуществляет «множественное наследование» поведения:

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();
    }
}

Перечислите интерфейсы через запятую после implements. Класс должен удовлетворять им всем.

Методы default и static

Начиная с Java 8 интерфейс может содержать тела методов. Метод default даёт реализующим классам готовую реализацию, которую они наследуют бесплатно (и могут переопределить):

interface Greeter {
    String name();

    default String greet() {        // общая реализация
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() наследуется от интерфейса
}

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

Методы default позволяют интерфейсу развиваться — добавлять метод, не ломая каждую существующую реализацию. Метод интерфейса static, напротив, — это утилита, которую вы вызываете у самого интерфейса, как Comparator.naturalOrder().

Константы

Поля в интерфейсе неявно являются public static final — это константы, а не состояние экземпляра:

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

Интерфейсы традиционно не хранят состояния отдельного объекта; отсутствие полей экземпляра — часть того, что отличает их от классов.

Функциональные интерфейсы

Интерфейс ровно с одним абстрактным методом является функциональным интерфейсом, и его можно реализовать лямбда-выражением вместо целого класса:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // лямбда реализует единственный метод
        System.out.println(doubler.apply(21));
    }
}

Это основа лямбд Java и типов из java.util.function (Function, Predicate, Supplier и им подобных). Аннотация @FunctionalInterface делает намерение явным и позволяет компилятору следить за соблюдением правила единственного метода.

Интерфейс против абстрактного класса

Оба позволяют программировать на уровне абстракции, так когда же выбирать тот или иной?

• Интерфейс — возможность, которую могут разделять несвязанные классы. И Bird, и Airplane могут быть Flyable. Класс может реализовать множество интерфейсов. Без состояния экземпляра.
• Абстрактный класс — общее состояние и код среди тесно связанных классов. И Cat, и Dog наследуют Animal, получая общие поля и частично реализованные методы. Класс наследует только один.

Распространённый шаблон сочетает их: интерфейс определяет контракт, а абстрактный класс реализует шаблонные части, чтобы конкретные подклассы заполняли лишь специфические детали.

Далее: абстрактные классы

Интерфейсы определяют поведение без состояния. Абстрактные классы находятся между интерфейсами и полноценными классами — они могут объявлять нереализованные методы и нести поля и конструкторы. Это тема следующей страницы.