Что такое recursive type bound

Обычное ограничение говорит: «T должен быть числом». Рекурсивное ограничение > говорит: «T должен быть не просто сравнимым с чем угодн...

🟢 Junior Level

Recursive type bound (рекурсивное ограничение типа) — это объявление параметра типа дженерика, в котором этот параметр ограничен типом, зависящим от самого этого параметра:

public class Box<T extends Comparable<T>> {
    private final T value;

    public Box(T value) {
        this.value = value;
    }

    public boolean isGreaterThan(T other) {
        return value.compareTo(other) > 0;
    }
}

Простая интуиция: «Я могу взаимодействовать с такими же, как я»

Обычное ограничение <T extends Number> говорит: «T должен быть числом».
Рекурсивное ограничение <T extends Comparable<T>> говорит: «T должен быть не просто сравнимым с чем угодно, а сравнимым с самим собой (объектами того же типа T)».

Благодаря этому:

Box<Integer> валиден, так как Integer implements Comparable<Integer>.
Box<String> валиден, так как String implements Comparable<String>.
Попытка сравнить Integer со String будет отклонена компилятором на этапе сборки.

🟡 Middle Level

Классический пример из JDK: `java.lang.Enum`

Наиболее известный пример рекурсивного ограничения в Java — это объявление базового класса перечислений:

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
    private final String name;
    private final int ordinal;

    public final int compareTo(E o) {
        return Integer.compare(this.ordinal, o.ordinal);
    }
}

Когда мы пишем:

public enum Season { WINTER, SPRING, SUMMER, AUTUMN }

Компилятор преобразует это в класс:

public final class Season extends Enum<Season> { ... }

Здесь тип Season подставляется в качестве параметра E.
Зачем это нужно? Метод compareTo(E o) принимает аргумент типа Season. Это на этапе компиляции гарантирует, что нельзя случайно сравнить значение одного enum с другим:

enum Status { ACTIVE, INACTIVE }

// ❌ Ошибка компиляции: Season не совместим со Status
Season.WINTER.compareTo(Status.ACTIVE); 

Паттерн Self-Bounding Types для Fluent Builder

В объектно-ориентированном дизайне рекурсивные границы часто используются для реализации наследуемых Fluent API (аналог Curiously Recurring Template Pattern — CRTP):

public abstract class AbstractBuilder<B extends AbstractBuilder<B>> {
    protected String name;

    @SuppressWarnings("unchecked")
    protected B self() {
        return (B) this;
    }

    public B withName(String name) {
        this.name = name;
        return self(); // Возвращает точный подкласс, а не базовый AbstractBuilder
    }
}

public class UserBuilder extends AbstractBuilder<UserBuilder> {
    private int age;

    public UserBuilder withAge(int age) {
        this.age = age;
        return this;
    }

    public User build() {
        return new User(name, age);
    }
}

// Использование цепочки методов базового и дочернего классов без кастов:
User user = new UserBuilder()
    .withName("Alice") // Возвращает UserBuilder!
    .withAge(30)       // Метод доступен в цепочке
    .build();

🔴 Senior Level

Проблема наследования и Relaxed Recursive Bound (`? super T`)

Рассмотрим на первый взгляд корректный generic-метод поиска максимума:

public static <T extends Comparable<T>> T naiveMax(List<T> list) { ... }

Представим типовую иерархию классов:

public class Animal implements Comparable<Animal> {
    protected int weight;
    @Override
    public int compareTo(Animal other) {
        return Integer.compare(this.weight, other.weight);
    }
}

public class Dog extends Animal {
    // Dog НЕ реализует Comparable<Dog>!
    // Dog наследует реализацию Comparable<Animal> от предка!
}

Что произойдёт при вызове naiveMax?

List<Dog> dogs = List.of(new Dog(), new Dog());
// ❌ ОШИБКА КОМПИЛЯЦИИ:
// Inference variable T has incompatible bounds:
// equality constraints: Dog
// upper bounds: Comparable<Dog>
Animal maxDog = naiveMax(dogs);

Класс Dog реализует Comparable<Animal>, а не Comparable<Dog>. Условие <T extends Comparable<T>> требует строгого равенства аргумента интерфейса с самим типом.

Решение: Использование `? super T` (Relaxed Bound)

Спецификация и стандартная библиотека Java формулируют ограничение с подстановочным знаком:

public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll)

Теперь компилятор проверяет: «Является ли T сравнимым с T или с любым из суперклассов T?». Для Dog суперкласс Animal реализует Comparable<Animal>, и условие выполняется идеально.

Загадка сигнатуры `Collections.max` в JDK

В исходном коде java.util.Collections метод max объявлен следующим образом:

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

Зачем здесь добавлен избыточный <T extends Object & ...>?

Это фундаментальный артефакт обратной бинарной совместимости (Binary Compatibility) с версией Java 1.4:

В Java 1.4 метод Collections.max имел сигнатуру:
```
public static Object max(Collection coll)
```
В Java 5 при стирании типов (Type Erasure) типом стирания generic-параметра становится его первая верхняя граница (first bound).
Если бы метод объявили как <T extends Comparable<? super T>>, стёртым типом возвращаемого значения стал бы java.lang.Comparable:
```
public static Comparable max(Collection coll) // Сломало бы старые class-файлы!
```
Добавление Object в качестве первой границы (<T extends Object & Comparable...>) гарантировало, что после стирания дескриптор метода в байт-коде остался в точности равен (Ljava/util/Collection;)Ljava/lang/Object;. Старый байт-код, скомпилированный под Java 1.4, продолжил работать без перекомпиляции!

4 каверзных вопроса

1. Почему в `Enum<E extends Enum<E>>` нельзя передать сторонний класс, например `class Fake extends Enum<Fake>`?

Ответ:
Компилятор javac явно запрещает прямое наследование от класса java.lang.Enum в исходном коде: classes cannot directly extend java.lang.Enum. Создавать подклассы Enum разрешено исключительно через ключевое слово enum.
Однако сама рекурсивная конструкция дженерика <E extends Enum<E>> на уровне системы типов предотвращает смешивание различных перечислений в обобщенных методах (например, в EnumSet.noneOf(Class<E>)), гарантируя, что все элементы набора принадлежат одному и тому же enum-типу.

2. Защищает ли паттерн `Builder<B extends Builder<B>>` от передачи некорректного типа наследника на этапе компиляции?

Ответ:
Не полностью. Разработчик может допустить ошибку и передать «чужой» тип:

public class SubBuilderA extends AbstractBuilder<SubBuilderA> { ... }
// Ошибка программиста: подставил SubBuilderA вместо SubBuilderB:
public class SubBuilderB extends AbstractBuilder<SubBuilderA> { ... }

Компилятор Java пропустит такое объявление, поскольку SubBuilderA действительно расширяет AbstractBuilder<SubBuilderA>.
В Java нельзя декларативно заставить дженерик ссылаться строго на объявляемый класс без вспомогательных проверок времени выполнения (например, self().getClass() == getClass()) или запечатанных иерархий (sealed classes), появившихся в Java 17.

3. Во что превращается рекурсивная граница `<T extends Comparable<T>>` после стирания типов?

Ответ:
Стирание типа (erasure) заменяет переменную типа её первой верхней границей (JLS §4.6).
Стиранием Comparable<T> является сырой тип Comparable. Следовательно, в байт-коде:

Поле T value превращается в Comparable value.
Метод T find(T arg) превращается в Comparable find(Comparable arg).
В местах вызова методов T компилятор автоматически вставляет инструкцию checkcast.

4. Почему нельзя объявить рекурсивную границу с `super`, например `<T super MyClass<T>>`?

Ответ:
Ключевое слово super в дженериках Java запрещено при объявлении параметров типов (type parameters). Оно допустимо исключительно в подстановочных знаках (wildcards: <? super T>).
Причина в том, что тип должен иметь определённую верхнюю границу, чтобы компилятор знал, какими методами обладает объект при обращении к нему. Нижняя граница не даёт никакой информации о доступных методах (сверху остаётся только Object).

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

Что это такое: Параметр типа, ограниченный выражением, содержащим сам этот параметр (<T extends Comparable<T>>).
Зачем нужен: Чтобы выразить отношение взаимной совместимости типов (например, элемент может сравниваться только с объектами своего же типа).
Главный пример из JDK: Enum<E extends Enum<E>> гарантирует, что Season.WINTER.compareTo(...) принимает только Season, защищая от сравнения разных enum-ов.
Ловушка с наследованием: Ограничение <T extends Comparable<T>> ломается на подклассах, так как подкласс наследует Comparable<Parent>. Решение: Relaxed Bound <T extends Comparable<? super T>>.
Секрет Collections.max: <T extends Object & Comparable<? super T>> содержит фиктивный Object &, чтобы при стирании типов возвращаемое значение в байт-коде оставалось Object для бинарной совместимости с Java 1.4.
Fluent Builder: Используется для возврата точного типа подкласса из методов родительского класса (AbstractBuilder<B extends AbstractBuilder<B>>).

🟢 Junior Level

Простая интуиция: «Я могу взаимодействовать с такими же, как я»

🟡 Middle Level

Классический пример из JDK: java.lang.Enum

Паттерн Self-Bounding Types для Fluent Builder

🔴 Senior Level

Проблема наследования и Relaxed Recursive Bound (? super T)

Решение: Использование ? super T (Relaxed Bound)

Загадка сигнатуры Collections.max в JDK

4 каверзных вопроса

1. Почему в Enum<E extends Enum<E>> нельзя передать сторонний класс, например class Fake extends Enum<Fake>?

2. Защищает ли паттерн Builder<B extends Builder<B>> от передачи некорректного типа наследника на этапе компиляции?

3. Во что превращается рекурсивная граница <T extends Comparable<T>> после стирания типов?

4. Почему нельзя объявить рекурсивную границу с super, например <T super MyClass<T>>?