🟢 Junior Level

Bridge method — это специальный метод, который компилятор Java создаёт автоматически для сохранения полиморфизма при работе с дженериками.

Это происходит из-за type erasure — когда дженерик-тип стирается, и сигнатуры методов меняются.

public class Node<T> {
    private T data;
    public void setData(T data) { this.data = data; }
    public T getData() { return data; }
}

public class StringNode extends Node<String> {
    @Override
    public void setData(String data) { super.setData(data); }
    @Override
    public String getData() { return super.getData(); }
}

После type erasure Node<String>.setData(String) становится setData(Object), но StringNode.setData(String) остаётся setData(String). Это разные методы!

Чтобы полиморфизм работал, компилятор создаёт bridge method:

// Автоматически добавляется в StringNode
public void setData(Object data) {
    setData((String) data);  // вызывает оригинальный метод
}

---

🟡 Middle Level

Зачем нужны bridge methods

Проблема:

// До type erasure:
Node<String> node = new StringNode();
node.setData("Hello");  // должно вызывать StringNode.setData(String)

// После type erasure:
Node node = new StringNode();
node.setData("Hello");  // Node.setData(Object) — но у StringNode только setData(String)!

Решение — bridge method:

class StringNode extends Node {
    // Оригинальный метод
    public void setData(String data) { /* ... */ }
    
    // Bridge method (создан компилятором)
    public void setData(Object data) {
        setData((String) data);  // делегирует оригинальному
    }
}

Как увидеть bridge method

Через reflection:

for (Method m : StringNode.class.getDeclaredMethods()) {
    System.out.println(m.getName() + " " + 
        Arrays.toString(m.getParameterTypes()) +
        " bridge=" + m.isBridge());
}

// Вывод:
// setData [class java.lang.String] bridge=false
// setData [class java.lang.Object] bridge=true

Через javap:

javap -p StringNode.class

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

1. Непонимание почему вызывается метод: ```java StringNode node = new StringNode(); node.setData(new Object()); // ClassCastException!

// Вызывается bridge method -> cast to String -> exception

2. **Аннотации на bridge methods:**
```java
public class StringNode extends Node<String> {
    @Override
    @MyAnnotation  // ❌ не попадёт на bridge method
    public void setData(String data) { }
}

---

🔴 Senior Level

Internal Implementation

JLS Specification:

JLS 15.12.4.5:
- При override метода с другой сигнатурой (после erasure)
- Компилятор создаёт bridge method с signature parent класса
- Bridge method делегирует original method с cast

Десугаризация:

// Исходный код
public class Node<T> {
    public T getData() { return data; }
    public void setData(T data) { this.data = data; }
}

public class StringNode extends Node<String> {
    @Override
    public String getData() { return super.getData(); }
    @Override
    public void setData(String data) { super.setData(data); }
}

// После компиляции:
class Node {
    public Object getData() { return data; }
    public void setData(Object data) { this.data = data; }
}

class StringNode extends Node {
    public String getData() { return (String) super.getData(); }
    
    // Bridge method для getData
    public Object getData() { return getData(); }
    
    public void setData(String data) { super.setData(data); }
    
    // Bridge method для setData
    public void setData(Object data) { setData((String) data); }
}

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

Bridge methods:

Плюсы	Минусы
Сохраняют полиморфизм	Дополнительные методы
Прозрачны для разработчика	Путаница в stack trace
Позволяют covariant return types	Аннотации не наследуются

Edge Cases

1. Covariant return type:

public class Parent {
    public Number getValue() { return 0; }
}

public class Child extends Parent {
    @Override
    public Integer getValue() { return 0; }
}

// Bridge method в Child:
// public Number getValue() { return getValue(); }  // delegate to Integer version

// Bridge возвращает Number, вызывает Integer getValue().
// Auto-boxing обрабатывается отдельно — Integer уже объект.

2. Multiple inheritance:

// Java НЕ позволяет реализовать два интерфейса с одинаковой сигнатурой
// но разными return types. Компилятор отклоняет это на уровне исходного кода.
// Bridge methods генерируются только для covariant returns.

3. Generic methods:

public class Util {
    public static <T> T identity(T t) { return t; }
}

// При вызове с разными типами — один метод после erasure
Util.identity("Hello");  // T = String
Util.identity(42);       // T = Integer
// Оба вызывают identity(Object)

4. Annotation workaround:

// Аннотации не попадают на bridge method
// Решение: используйте @Inherited meta-annotation или reflection,
// который проверяет isBridge() и ищет оригинальный метод.

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

Bridge method overhead:
- Один дополнительный вызов (delegate)
- JIT инлайнит bridge methods
- Overhead: ~0-1 ns (практически ноль)

В production: negligible

Production Experience

JDK примеры:

// Collections — bridge methods для covariant returns
public class ArrayList<E> extends AbstractList<E> {
    @Override
    public Object clone() { return super.clone(); }
    // Bridge: public Object clone() from Object
}

// Enum — bridge для compareTo
public abstract class Enum<E extends Enum<E>> implements Comparable<E> {
    public final int compareTo(E o) { return ordinal - o.ordinal; }
    // Bridge: public int compareTo(Object o) { return compareTo((E) o); }
}

Reflection с bridge methods:

Method[] methods = StringNode.class.getDeclaredMethods();
for (Method m : methods) {
    if (m.isBridge()) {
        System.out.println("Bridge: " + m);
        // Найти оригинальный метод
        Method original = findOriginal(m);
        System.out.println("Original: " + original);
    }
}

Serialization:

// Bridge methods не сериализуются отдельно
// Сериализуется только класс, методы восстанавливаются

Best Practices

// ✅ Не беспокоиться о bridge methods — они прозрачны
// ✅ Использовать @Override для ясности
@Override
public String getData() { return super.getData(); }

// ⚠️ Аннотации не попадают на bridge method
// ✅ Если нужны аннотации — добавить на оба метода

// ❌ Не вызывать bridge methods напрямую
// ❌ Не полагаться на existence bridge methods

---

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

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

• Bridge method — синтетический метод, создаваемый компилятором для сохранения полиморфизма
• Причина: type erasure меняет сигнатуры методов, нарушая override
• Bridge method делегирует оригинальному методу с cast параметров
• Можно увидеть через reflection: method.isBridge()或通过 javap -p
• Аннотации НЕ попадают на bridge method — нужно добавлять на оба метода
• Overhead negligible: JIT инлайнит bridge methods (~0-1 ns)

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

• Зачем нужны bridge methods? — Сохранить полиморфизм после type erasure (parent method signature != child)
• Как увидеть bridge method? — javap -p ClassName или method.isBridge() через reflection
• Могут ли bridge methods вызвать ClassCastException? — Да, если вызвать с неправильным типом
• Аннотации работают на bridge methods? — Нет, только на оригинальном методе

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

• ❌ “Bridge methods — это методы разработчика” — Они создаются компилятором автоматически
• ❌ “Bridge methods добавляют значительный overhead” — JIT инлайнит, overhead ~0-1 ns
• ❌ “Аннотации автоматически попадают на bridge methods” — Нет, нужна meta-аннотация или ручная обработка
• ❌ “Bridge methods — баг Java” — Это intentional design для совместимости с type erasure

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

• [[11. Что такое дженерики (Generics) в Java]]
• [[13. Что такое type erasure (стирание типов)]]
• [[22. Можно ли перегружать методы, отличающиеся только дженерик-параметрами]]
• [[24. Как работают дженерики с наследованием]]