🧬 ООП: классы, интерфейсы, 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 time | Runtime, динамическая диспетчеризация |
При вызове 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. конструктор PaymentClienturl объявлен final, но в connect он null, значение по умолчанию. Исключение, на котором легко запутаться: с private final String url = "https://pay" вывод будет с адресом, потому что константу времени компиляции компилятор подставляет прямо в код метода. Обычное поле или final с результатом вызова в этот момент ещё пустые
Подробнее про загрузку классов — в модуле «Как устроена JVM»
Неизменяемый класс
Неизменяемый объект можно без синхронизации отдавать в другие потоки и класть ключом в HashMap. Рецепт:
- класс
final, чтобы потомок не добавил изменяемое состояние - все поля
private final, без сеттеров - изменяемые входные данные копируются в конструкторе:
List.copyOf(items) - наружу изменяемое состояние не отдаётся, либо отдаётся копия
- «изменение» возвращает новый объект:
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 в интерфейсах | — |
| 9 | private-методы в интерфейсах | — |
| 10 | var для локальных переменных | 286 |
| 15 | text blocks """ | 378 |
| 16 | records, pattern matching для instanceof | 395, 394 |
| 17 | sealed-классы и интерфейсы | 409 |
| 21 | pattern matching для switch, record patterns | 441, 440 |
| 25 | void 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). Пример из своего кода звучит сильнее определений
📚 Что почитать
- JLS, глава 12.5: создание экземпляров класса — формальный порядок инициализации, на который можно сослаться в споре
- JEP 441: Pattern Matching for switch — исчерпываемость, доминирование веток,
nullиMatchException - JEP 513: Flexible Constructor Bodies — пример с переопределённым методом в конструкторе и как Java 25 его исправляет
- dev.java: Records — компактный конструктор и ограничения record с примерами