🟢 Junior Level

Нет, нельзя. Record в Java имеет два жёстких ограничения:

1. Record нельзя расширить — Record является implicit final
2. Record не может наследовать другой класс — все Record автоматически наследуются от java.lang.Record

// ❌ Нельзя наследоваться от Record
public record Point(int x, int y) {}
public class Bad extends Point {}  // compilation error

// ❌ Record не может расширять другой класс
public record Bad extends Object {}  // compilation error
// Record всегда extends java.lang.Record

Но можно имплементировать интерфейсы:

public record User(String name) implements Serializable, Comparable<User> {
    @Override
    public int compareTo(User other) {
        return this.name.compareTo(other.name);
    }
}

---

🟡 Middle Level

Почему такие ограничения?

Record создан для простой передачи данных, а не для объектно-ориентированного наследования.

Причины:

1. Гарантия иммутабельности — если бы можно было расширить Record, подкласс мог бы добавить mutable поля
2. Предсказуемое поведение — equals(), hashCode() всегда работают одинаково
3. Оптимизация JVM — JIT может делать предположения о структуре
4. Value types совместимость — подготовка к Project Valhalla

Практическое применение

Вместо наследования — композиция:

// ❌ Нельзя
public record AuditedRecord(String name) extends BaseEntity {}

// ✅ Можно через композицию
public record BaseEntity(LocalDateTime createdAt, String createdBy) {}
public record User(String name, BaseEntity audit) {}

// Или через интерфейс
public interface Auditable {
    LocalDateTime createdAt();
    String createdBy();
}

public record User(String name, LocalDateTime createdAt, String createdBy) implements Auditable {}

Типичные ошибки

1. Попытка использовать с Hibernate: ```java // ❌ JPA требует наследования от базового entity @Entity public record User(Long id, String name) {} // не работает

// ✅ Обычный класс для JPA @Entity public class User { @Id private Long id; private String name; }

2. **Ожидание полиморфизма:**
```java
// Record не поддерживает полиморфизм через наследование классов, но поддерживает
// через интерфейсы и sealed types.
public record Circle(double radius) {}
public record Rectangle(double w, double h) {}

// ✅ Используйте sealed interfaces + pattern matching (Java 21+)
public sealed interface Shape permits Circle, Rectangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}

double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.w() * r.h();
    };
}

---

🔴 Senior Level

Internal Implementation

Class file structure:

// Record имеет ACC_FINAL | ACC_RECORD флаги
// super_class всегда указывает на java/lang/Record

ClassFile {
    access_flags: ACC_FINAL | ACC_RECORD  // implicit final
    super_class: constant_pool[java/lang/Record]
    interfaces_count: N  // может имплементировать интерфейсы
}

JVM specification (JVMS 4.7.31 — Record attribute и JVMS 4.1 — access_flags ACC_RECORD):

• Record должен иметь ACC_FINAL флаг
• Super class должен быть java.lang.Record
• Нельзя изменить через bytecode manipulation

Архитектурные Trade-offs

Почему нельзя расширять:

1. Нарушение инкапсуляции — подкласс может изменить поведение equals/hashCode
2. Проблемы с hashCode контрактом — разные подклассы могут иметь разные поля
3. Сериализация — сложно определить canonical form для иерархии
4. Pattern matching — деструктуризация требует фиксированной структуры

Edge Cases

1. Sealed interfaces как альтернатива:

public sealed interface Event permits UserCreated, UserDeleted, OrderPlaced {}

public record UserCreated(String userId, Instant timestamp) implements Event {}
public record UserDeleted(String userId, String reason) implements Event {}
public record OrderPlaced(String orderId, BigDecimal amount) implements Event {}

// Pattern matching для обработки
String process(Event event) {
    return switch (event) {
        case UserCreated uc -> "User created: " + uc.userId();
        case UserDeleted ud -> "User deleted: " + ud.userId();
        case OrderPlaced op -> "Order placed: " + op.orderId();
    };
}

2. Generic Records:

public record ApiResponse<T>(int status, T data, String message) {}

// Специализация через интерфейсы
public interface Validated {}
public record ValidatedResponse<T>(ApiResponse<T> response, boolean isValid) 
    implements Validated {}

3. Composition over inheritance:

public record Pagination(int page, int size) {}
public record Sort(String field, Direction direction) {}

public record PagedRequest(Pagination pagination, Sort sort, String filter) {}

// Вместо:
// public class PagedRequest extends Pagination { Sort sort; String filter; }

Производительность

Наследование vs Композиция:
- Наследование: чуть быстрее доступ к полям (один уровень)
- Композиция: negligible overhead (дополнительная ссылка)
- JIT инлайнит оба подхода эффективно
- Разница < 1% в реальных приложениях

Production Experience

Реальный кейс — Event Sourcing:

// Event-driven архитектура с sealed + records
public sealed interface DomainEvent {
    UUID eventId();
    Instant occurredAt();
}

public record UserCreatedEvent(
    UUID eventId, Instant occurredAt, String userId, String name
) implements DomainEvent {}

public record UserEmailChangedEvent(
    UUID eventId, Instant occurredAt, String userId, String oldEmail, String newEmail
) implements DomainEvent {}

// Обработка
public void handle(DomainEvent event) {
    switch (event) {
        case UserCreatedEvent e -> createUser(e.userId(), e.name());
        case UserEmailChangedEvent e -> updateEmail(e.userId(), e.newEmail());
    }
}

Best Practices

// ✅ Sealed interfaces + records для полиморфизма
public sealed interface Payment permits CashPayment, CardPayment, CryptoPayment {}
public record CashPayment(BigDecimal amount) implements Payment {}
public record CardPayment(BigDecimal amount, String cardNumber) implements Payment {}
public record CryptoPayment(BigDecimal amount, String walletAddress) implements Payment {}

// ✅ Композиция для повторного использования
public record AuditInfo(LocalDateTime createdAt, String createdBy) {}
public record User(String name, String email, AuditInfo audit) {}

// ❌ Не пытайтесь эмулировать наследование
// ❌ Не используйте Record для JPA entities
// ❌ Не используйте Record для mutable state

---

🎯 Шпаргалка для интервью

Обязательно знать:

• Record нельзя расширить — implicit final (ACC_FINAL флаг)
• Record не может наследовать другой класс — всегда extends java.lang.Record
• Record может имплементировать интерфейсы: record User implements Serializable
• Альтернатива наследованию — композиция или sealed interfaces
• Sealed interfaces + Records + pattern matching = замена полиморфизма
• JVM запрещает extends Record на уровне bytecode (ACC_RECORD флаг)

Частые уточняющие вопросы:

• Почему Record нельзя расширить? — Для гарантии иммутабельности, предсказуемого equals/hashCode и оптимизации JVM
• Как реализовать полиморфизм с Records? — Sealed interfaces + pattern matching (Java 21+)
• Можно ли использовать Record с Hibernate? — Нет, JPA требует наследование и mutable state
• Чем композиция лучше наследования для Records? — Сохраняет иммутабельность, не нарушает контракт Record

Красные флаги (НЕ говорить):

• ❌ “Можно расширить Record через промежуточный класс” — Запрещено на уровне JVM
• ❌ “Record наследует Object” — Record наследует java.lang.Record
• ❌ “Record поддерживает полиморфизм через наследование” — Только через интерфейсы и sealed types
• ❌ “Можно использовать Record для JPA entity иерархии” — JPA не поддерживает Records

Связанные темы:

• [[1. Что такое Record в Java и с какой версии они доступны]]
• [[2. В чём основные отличия Record от обычного класса]]
• [[4. Можно ли добавлять дополнительные методы в Record]]
• [[17. Что такое PECS (Producer Extends Consumer Super)]]