Что такое recursive type bound

🟢 Junior Level

Recursive type bound — это когда type parameter ограничен самим собой или типом, который использует этот же parameter.

// T должен быть Comparable к самому себе
public class SortedList<T extends Comparable<T>> {
    private List<T> list = new ArrayList<>();
    
    public void add(T item) {
        list.add(item);
        list.sort(Comparable::compareTo);
    }
}

SortedList<Integer> ints = new SortedList<>();    // ✅ Integer implements Comparable<Integer>
SortedList<String> strings = new SortedList<>();  // ✅ String implements Comparable<String>

Простая аналогия: “Я могу сравниваться с такими же, как я”

🟡 Middle Level

Как это работает

Классический пример — Enum:

// Java Enum declaration
public abstract class Enum<E extends Enum<E>> 
    implements Comparable<E> {
    
    public final int compareTo(E other) {
        return this.ordinal - other.ordinal;
    }
}

// Использование
enum Color { RED, GREEN, BLUE }
// Color extends Enum<Color>
// Color implements Comparable<Color>

Зачем это нужно:

// Без recursive bound — нельзя гарантировать type safety
public class Box<T extends Comparable<T>> {
    private T value;
    
    public int compare(T other) {
        return value.compareTo(other);  // ✅ type-safe
    }
}

Box<Integer> box = new Box<>();
box.compare(42);  // OK

// Box<Object> box2 = new Box<>();  // ❌ Object не implements Comparable<Object>

Self-bounding types

Паттерн для fluent interfaces:

public abstract class Builder<T, B extends Builder<T, B>> {
    protected abstract B self();
    
    public B withName(String name) {
        // ... setup
        return self();
    }
    
    public B withAge(int age) {
        // ... setup
        return self();
    }
    
    public T build() {
        // ... build
    }
}

public class UserBuilder extends Builder<User, UserBuilder> {
    @Override
    protected UserBuilder self() { return this; }
}

// Fluent API
User user = new UserBuilder()
    .withName("John")
    .withAge(25)
    .build();

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

Неправильный recursive bound: ```java // ❌ T extends Comparable

// ✅ T extends Comparable — recursive public class GoodBox<T extends Comparable> { }

2. **Слишком строгий bound:**
```java
// ❌ T должен быть точно Comparable<T>
public class Box<T extends Comparable<T>> { }

// ⚠️ Не пройдёт для некоторых типов
// Некоторые классы реализуют Comparable к super типу

🔴 Senior Level

Internal Implementation

Type erasure recursive bounds:

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

// После erasure: T -> Comparable (первый bound)
public class Box {
    private Comparable value;
}

Nested recursive bounds:

// Сложный случай — Enum<E extends Enum<E>>
// T должен быть Enum<T>
// Enum<T> implements Comparable<T>
// Значит T implements Comparable<T>

public class Enum<E extends Enum<E>> implements Comparable<E> {
    // E — это конкретный enum тип
    // compareTo принимает тот же enum тип
}

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

Recursive bounds vs обычные:

Recursive	Обычные
Type-safe сравнение	Может быть менее точным
Fluent interfaces	Simpler
Сложнее понять	Проще

Edge Cases

1. Multiple recursive bounds:

public class Graph<N extends Node<N, E>, E extends Edge<N, E>> {
    private List<N> nodes;
    private List<E> edges;
}

public interface Node<N extends Node<N, E>, E extends Edge<N, E>> {
    List<E> getEdges();
}

public interface Edge<N extends Node<N, E>, E extends Edge<N, E>> {
    N getSource();
    N getTarget();
}

2. Relaxed recursive bound:

// T должен быть Comparable к super типу T
public class SortedList<T extends Comparable<? super T>> {
    // Это relaxes bound — позволяет наследникам тоже работать
}

// ? super T нужен потому что подклассы наследуют Comparable<SuperType>.
// Например, Dog extends Animal implements Comparable<Animal>.
// Без ? super T Dog не удовлетворял бы Comparable<Dog>.

// Например:
class Date implements Comparable<Date> { }
class java.sql.Date extends Date { }
// java.sql.Date implements Comparable<Date> (через наследование)
// Но не Comparable<java.sql.Date>
// С ? super T — работает!

3. CRTP (Curiously Recurring Template Pattern):

// Реальное использование: Enum<E extends Enum<E>> — каждый enum тип
// сравнивается только с собой. Это гарантирует type-safe compareTo.

// Паттерн из C++, адаптированный для Java
public abstract class SelfComparable<T extends SelfComparable<T>>
    implements Comparable<T> {

    public abstract int compareTo(T other);
}

public class MyType extends SelfComparable<MyType> {
    private int value;

    @Override
    public int compareTo(MyType other) {
        return Integer.compare(this.value, other.value);
    }
}

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

Recursive bounds:
- Runtime: Zero overhead
- Compile time: сложная проверка
- Type erasure: bound становится типом

Производительность одинакова для всех bound типов

Production Experience

JDK примеры:

// Enum — классический recursive bound
public abstract class Enum<E extends Enum<E>> 
    implements Comparable<E> { }

// Collections.max
public static <T extends Object & Comparable<? super T>> T max(
    Collection<? extends T> coll
) { }

// Builder pattern
public abstract class AbstractQueryBuilder<B extends AbstractQueryBuilder<B>> {
    protected abstract B self();
    
    public B where(String condition) {
        // ...
        return self();
    }
}

Real-world example:

// Entity с self-type для builder
public abstract class BaseEntity<E extends BaseEntity<E>> {
    private Long id;
    
    @SuppressWarnings("unchecked")
    public E withId(Long id) {
        this.id = id;
        return (E) this;
    }
}

public class User extends BaseEntity<User> {
    private String name;
    
    public User withName(String name) {
        this.name = name;
        return this;
    }
}

User user = new User()
    .withId(1L)
    .withName("John");

Best Practices

// ✅ Recursive bound для сравнения
public class SortedList<T extends Comparable<T>> { }

// ✅ Relaxed bound для наследников
public class SortedList<T extends Comparable<? super T>> { }

// ✅ Self-bounding для fluent API
public abstract class Builder<B extends Builder<B>> {
    protected abstract B self();
}

// ❌ Слишком сложные recursive bounds
// ❌ Recursive bounds без необходимости

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

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

Recursive type bound: <T extends Comparable<T>> — тип ограничен самим собой
Классический пример — Enum<E extends Enum<E>> — каждый enum сравнивается с собой
Self-bounding types для fluent API: Builder<B extends Builder<B>> возвращает B
Relaxed recursive bound: <T extends Comparable<? super T>> — позволяет наследникам
CRTP (Curiously Recurring Template Pattern) — паттерн из C++, адаптированный для Java
Type erasure: T extends Comparable<T> -> erasure = Comparable

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

Зачем нужен recursive bound? — Гарантировать type-safe сравнение: T сравнивается с T, не с Object
Почему Enum использует recursive bound? — Чтобы Color.compareTo(Color) принимал Color, не Enum
Что такое relaxed recursive bound? — ? super T позволяет подклассам наследовать Comparable
Где используется self-bounding? — Fluent builder pattern: withName().withAge().build()

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

❌ “Recursive bound создаёт бесконечную рекурсию” — Это compile-time ограничение, не runtime
❌ “Enum<E extends Enum> — странность Java" — Это гарантирует type-safe compareTo
❌ “Self-bounding — это только для builder” — Также для graph nodes, entities, comparables
❌ “Relaxed bound менее безопасен” — ? super T безопаснее, позволяет больше типов

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

[[11. Что такое дженерики (Generics) в Java]]
[[15. Что такое bounded type parameters]]
[[17. Что такое PECS (Producer Extends Consumer Super)]]
[[26. Можно ли использовать несколько ограничений (bounds) для одного параметра типа]]