К содержимому
Войти

Java Road Map

🧬 ООП: классы, интерфейсы, record и sealed

ООП в Java — это то, на чём держится любой сервис: контроллер зовёт интерфейс, Spring подставляет реализацию, платёжные шлюзы прячутся за общим контрактом. На собеседовании с этой темы начинают почти всегда и быстро уходят от определений к механике: какой метод вызовется, в каком порядке выполнится инициализация, почему компилятор не пропустил switch. Ниже всё это на примерах из бэкенда, плюс что поменялось в языке с 8 по 25

🧠 Как это устроено

Четыре принципа на одном сервисе

Возьмём оплату заказа. Инкапсуляция — поле status у Order закрыто, сменить его можно только через pay(), который проверяет, что заказ ещё не оплачен. Никакой контроллер не поставит PAID в обход проверки

Абстракция — сервис знает интерфейс PaymentGateway с методом charge(Order), но не знает, что за ним: эквайринг, СБП или заглушка в тестах

Наследование — SmsNotifier extends Notifier получает от родителя ретраи и логирование. Пользуются им осторожно: наследник зависит от деталей родителя, поэтому чаще собирают объект из частей (композиция)

Полиморфизм — один вызов gateway.charge(order) выполняет разный код смотря какой объект пришёл. Без него каждая платёжка добавляла бы ветку if

Перегрузка и переопределение

Оба механизма про методы с одним именем, но нужный метод выбирается в разное время

Перегрузка (overload)Переопределение (override)
Что этоМетоды с одним именем и разными параметрами в одном классеМетод потомка с той же сигнатурой, что у родителя
Кто выбираетКомпилятор, по объявленным типам аргументовJVM во время выполнения, по реальному классу объекта
КогдаCompile timeRuntime, динамическая диспетчеризация

При вызове JVM смотрит на класс самого объекта и ищет метод по цепочке наследования снизу вверх. Тип переменной важен только компилятору: по нему он выбирает перегрузку. Поэтому в примере ниже n.send(text) вызовет метод SmsNotifier, но именно версию с Object: перегрузку компилятор зафиксировал заранее, а JVM выбрала только реализацию

class Notifier {
    void send(Object msg) { System.out.println("Notifier.send(Object)"); }
    void send(String msg) { System.out.println("Notifier.send(String)"); }
}

class SmsNotifier extends Notifier {
    @Override
    void send(Object msg) { System.out.println("SmsNotifier.send(Object)"); }
}

Notifier n = new SmsNotifier();
Object text = "код 1234";
n.send(text);        // SmsNotifier.send(Object)
n.send("код 1234");  // Notifier.send(String) — String в потомке не переопределён

Правила переопределения, которые спрашивают:

  • сигнатура совпадает: имя и типы параметров
  • возвращаемый тип тот же или подтип. Это ковариантный возврат: Notifier copy() у родителя можно переопределить как SmsNotifier copy()
  • доступ не уже, чем у родителя: public нельзя сделать protected
  • checked-исключений не больше и не шире, чем у родителя. Unchecked можно любые
  • private, static и final методы не переопределяются. Статический метод с той же сигнатурой в потомке скрывает родительский, и какой вызовется, решает тип переменной

@Override в поведении ничего не меняет: компилятор лишь проверяет, что метод правда что-то переопределяет. Без аннотации опечатка sendd молча создаёт новый метод

Интерфейс или абстрактный класс

ИнтерфейсАбстрактный класс
СостояниеТолько константы (public static final)Любые поля
КонструкторНетЕсть, вызывается из потомка
Сколько можно унаследоватьСколько угодноОдин
Методы с теломdefault и static (с 8), private (с 9)Любые
Модификаторы методовpublic по умолчанию, ещё privateЛюбые

Интерфейс описывает, что объект умеет (PaymentGateway, Comparable), абстрактный класс даёт общую реализацию с состоянием, как AbstractList. Часто их сочетают: интерфейс как контракт, абстрактный класс реализует его скучную часть

default-методы появились в Java 8, чтобы добавлять методы в интерфейс, не ломая реализации: так в Collection появился stream(). static-методы интерфейса вызываются только через его имя и реализациями не наследуются. private-методы (с 9) выносят общий код нескольких default

Ромб у default-методов

Если класс реализует два интерфейса с одинаковым default-методом, компилятор не угадывает, какой взять:

interface Retryable { default int attempts() { return 3; } }
interface Auditable { default int attempts() { return 1; } }

class Job implements Retryable, Auditable {
    @Override
    public int attempts() { return Retryable.super.attempts(); }  // выбираем явно
}
// без переопределения: class Job inherits unrelated defaults for attempts()

Метод класса или суперкласса всегда побеждает default. Более конкретный интерфейс побеждает родительский: если B extends A, берётся версия из B. Иначе класс обязан переопределить метод сам

Порядок инициализации при наследовании

При первом обращении к классу JVM загружает и инициализирует его: сначала родителя, потом потомка. Статические поля и блоки выполняются один раз на класс. При каждом new дальше идёт цепочка: конструктор потомка первым делом вызывает super(...), родитель инициализирует свои поля и выполняет тело конструктора, и только после возврата из super инициализируются поля потомка и выполняется его тело

Ловушка: пока работает конструктор родителя, объект уже имеет класс потомка. Вызов переопределяемого метода уйдёт в потомка, чьи поля ещё не проинициализированы. Проверено на JDK 19:

class BaseClient {
    static { System.out.println("1. static BaseClient"); }
    private final String name = log("3. поле BaseClient");

    BaseClient() {
        System.out.println("4. конструктор BaseClient");
        connect();  // переопределённый метод из конструктора родителя
    }

    void connect() { }

    static String log(String s) { System.out.println(s); return s; }
}

class PaymentClient extends BaseClient {
    static { System.out.println("2. static PaymentClient"); }
    private final String url = log("5. поле PaymentClient");

    PaymentClient() { System.out.println("6. конструктор PaymentClient"); }

    @Override
    void connect() { System.out.println("   connect: url = " + url); }
}

new PaymentClient();
new PaymentClient();
1. static BaseClient
2. static PaymentClient
3. поле BaseClient
4. конструктор BaseClient
   connect: url = null
5. поле PaymentClient
6. конструктор PaymentClient
3. поле BaseClient
4. конструктор BaseClient
   connect: url = null
5. поле PaymentClient
6. конструктор PaymentClient

url объявлен final, но в connect он null, значение по умолчанию. Исключение, на котором легко запутаться: с private final String url = "https://pay" вывод будет с адресом, потому что константу времени компиляции компилятор подставляет прямо в код метода. Обычное поле или final с результатом вызова в этот момент ещё пустые

Подробнее про загрузку классов — в модуле «Как устроена JVM»

Неизменяемый класс

Неизменяемый объект можно без синхронизации отдавать в другие потоки и класть ключом в HashMap. Рецепт:

  1. класс final, чтобы потомок не добавил изменяемое состояние
  2. все поля private final, без сеттеров
  3. изменяемые входные данные копируются в конструкторе: List.copyOf(items)
  4. наружу изменяемое состояние не отдаётся, либо отдаётся копия
  5. «изменение» возвращает новый объект: order.withStatus(PAID)
public final class Order {
    private final String id;
    private final List<String> items;

    public Order(String id, List<String> items) {
        this.id = id;
        this.items = List.copyOf(items);  // защитная копия, заодно неизменяемая
    }

    public List<String> items() { return items; }  // List.copyOf уже нельзя изменить
}

record

record (финальный с Java 16) — короткая запись неизменяемого носителя данных. Из record Money(BigDecimal amount, String currency) компилятор генерирует:

  • private final поле на каждый компонент
  • канонический конструктор со всеми компонентами
  • методы доступа amount() и currency(), без префикса get
  • equals, hashCode и toString по всем компонентам. Как устроен контракт equals и hashCode — на соседней странице про методы Object

Компактный конструктор пишется без списка параметров и нужен для проверок и нормализации. Присваивать поля в нём не нужно, это сделает компилятор после тела:

record Money(BigDecimal amount, String currency) {
    Money {
        if (amount.signum() < 0) throw new IllegalArgumentException("amount < 0");
        currency = currency.toUpperCase();  // меняем параметр, поле получит уже его
    }
}
// new Money(new BigDecimal("990"), "rub") → Money[amount=990, currency=RUB]

Ограничения: record неявно final и ничего не наследует (родитель уже java.lang.Record), но реализует интерфейсы. Дополнительные поля экземпляра запрещены, static можно. Неизменяемость поверхностная: record Tags(List<String> list) хранит ту же ссылку, и правка исходного списка видна в record. Лечится той же копией в компактном конструкторе: list = List.copyOf(list);

JPA-сущностью record не сделать: Hibernate нужны конструктор без аргументов и изменяемые поля. Для DTO и ответов API он то, что надо

sealed и pattern matching

sealed (Java 17) ограничивает, кто может наследовать тип. Компилятор знает полный список подтипов, и switch по такому типу проверяется на исчерпываемость: если какой-то вариант забыт, код не скомпилируется. С Java 21 pattern matching для switch (JEP 441) и record patterns (JEP 440) финальные:

sealed interface Payment permits Card, Sbp, Invoice {}
record Card(String last4, BigDecimal amount) implements Payment {}
record Sbp(String phone, BigDecimal amount) implements Payment {}
record Invoice(String inn, BigDecimal amount, int days) implements Payment {}

static String describe(Payment p) {
    return switch (p) {
        case Card(String last4, BigDecimal a) -> "карта *" + last4 + ", " + a;
        case Sbp s when s.phone().startsWith("+7") -> "СБП " + s.phone();
        case Sbp s -> "СБП, чужой номер";
        case Invoice(var inn, var a, var days) -> "счёт " + inn + " на " + days + " дн.";
    };
}

default здесь не нужен и даже вреден: добавишь record Crypto(...) в permits, и компилятор сам покажет все switch, которые его не обрабатывают. С default новый тип молча уйдёт в общую ветку. Подтипы sealed-интерфейса обязаны быть final, sealed или non-sealed, а record уже final

Ещё три правила из JEP 441. Ветки проверяются сверху вниз, и ветка, перекрытая предыдущей, не скомпилируется: case Sbp s выше case Sbp s when ... не пропустят. null без case null даёт NullPointerException. Если исчерпывающий switch в рантайме не нашёл ветку (подтип добавили, а этот код не перекомпилировали), вылетит MatchException

Что изменилось с 8 по 25

ВерсияЧто появилосьJEP
8лямбды, Stream API, default и static в интерфейсах—
9private-методы в интерфейсах—
10var для локальных переменных286
15text blocks """378
16records, pattern matching для instanceof395, 394
17sealed-классы и интерфейсы409
21pattern matching для switch, record patterns441, 440
25void main() без класса, import module, код до super(...) в конструкторе512, 511, 513

LTS-версии — 8, 11, 17, 21 и 25. JEP 513 закрывает ловушку с инициализацией: поле потомка можно присвоить до super(...), и переопределённый метод родителя увидит настоящее значение. Инициализаторы в объявлении полей по-прежнему выполняются после super

SOLID на одном примере

Сервис оплаты с if (type.equals("card")) ... else if ... нарушает почти всё сразу. Как разложить:

  • S: PaymentService оркестрирует оплату, запросы к банку живут в CardGateway
  • O: новый способ оплаты — новый класс PaymentGateway, а не ветка if
  • L: сервис работает с любым шлюзом. Заглушка, которая кидает UnsupportedOperationException на refund, это нарушает
  • I: refund вынесен в Refundable, и шлюз без возвратов его не реализует
  • D: сервис получает List<PaymentGateway> через конструктор, реализации подставляет Spring

⚠️ Где ошибаются

Вызов переопределяемого метода из конструктора. Родитель зовёт init(), потомок его переопределяет и читает свои поля, а там null. В логах это NullPointerException из ниоткуда. В конструкторе вызывают только private или final методы

«Неизменяемый» класс без защитной копии. Поля final, сеттеров нет, но конструктор сохранил чужой ArrayList по ссылке, а геттер его же и вернул. final запрещает менять ссылку, а не содержимое

default в switch по sealed-типу. Его ставят «на всякий случай», и при новом подтипе компилятор молчит, а код уходит в общую ветку

Глубокие иерархии. Четыре уровня от BaseService до OrderService: правка в середине ломает всех потомков, а поведение собирают по четырём файлам. Композиция обычно проще

🎯 Вопросы с собеседований

Назови принципы ООП и объясни полиморфизм

Инкапсуляция, наследование, полиморфизм и абстракция. Полиморфизм — вызов через ссылку на интерфейс или родителя выполняет метод реального класса объекта: gateway.charge(order) уйдёт в карточный или СБП-шлюз смотря что подставили. JVM выбирает реализацию в рантайме, это динамическая диспетчеризация. Новый вариант добавляется классом, а не веткой if

Чем перегрузка отличается от переопределения?

Перегрузку выбирает компилятор по объявленным типам аргументов, переопределение выбирает JVM в рантайме по реальному классу объекта. Отсюда каверза: если переменная объявлена как Object, а внутри строка, вызовется перегрузка с Object, хотя есть версия со String. При переопределении возврат может быть подтипом (ковариантный возврат), доступ нельзя сужать, checked-исключения нельзя расширять

Интерфейс или абстрактный класс, что выбрать?

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

Зачем нужны default-методы и что будет при конфликте двух default?

Чтобы расширять интерфейсы без поломки реализаций, так в Java 8 в Collection появился stream(). Если класс получает одинаковый default из двух несвязанных интерфейсов, компиляция падает, и метод надо переопределить, выбрав версию через Retryable.super.attempts(). Метод класса всегда побеждает default, а более конкретный интерфейс побеждает своего родителя

В каком порядке инициализируется объект при наследовании?

Статика родителя, затем статика потомка, один раз на класс. Потом при каждом new: поля и блоки инициализации родителя, его конструктор, поля и блоки потомка, его конструктор. Если конструктор родителя вызовет переопределённый метод, тот выполнится в потомке, где поля ещё null или 0. Исключение — final-поля с константой времени компиляции: их компилятор подставляет заранее

Как сделать класс неизменяемым?

Класс final, поля private final, сеттеров нет. Изменяемый вход копируется в конструкторе через List.copyOf, наружу отдаётся неизменяемое представление или копия, «изменение» возвращает новый экземпляр. Чаще всего забывают защитные копии: final фиксирует ссылку, а не содержимое коллекции

Что генерирует record и какие у него ограничения?

Приватные final-поля, канонический конструктор, методы доступа по именам компонентов, equals, hashCode и toString. Проверки пишут в компактном конструкторе без списка параметров. Record неявно final, не наследует классы и не объявляет лишних полей экземпляра, но реализует интерфейсы и может иметь статику. Неизменяемость поверхностная: список внутри record меняется, если не сделать копию

Что дают sealed-классы вместе со switch?

sealed фиксирует список подтипов, и switch по нему с Java 21 проверяется на исчерпываемость без default. Добавил подтип — компилятор показал все места, где его не обработали. Record patterns сразу разбирают компоненты: case Card(String last4, var amount). Перекрытая ветка не компилируется, а null без case null даёт NullPointerException

Чем отличаются Java 8, 11, 17, 21 и 25 с точки зрения языка?

8 — лямбды, Stream API, default-методы. 11 — плюс модули из 9 и var из 10. 17 — records, text blocks, instanceof с шаблоном и sealed. 21 — pattern matching для switch, record patterns, виртуальные потоки. 25 — void main() без класса, import module, код до super(...)

Расскажи про SOLID на примере

Беру сервис оплаты с if по типу платежа и раскладываю: сервис оркестрирует, шлюзы ходят в банк (S), новый способ оплаты — новый PaymentGateway (O), любой шлюз подставляется без сюрпризов (L), возвраты в отдельном Refundable (I), сервис зависит от интерфейса, а реализации подставляет Spring (D). Пример из своего кода звучит сильнее определений

📚 Что почитать