С какой частью Core связано стирание типов

Стирание типов в Java: связь с компилятором и Runtime

Стирание типов (Type Erasure) — это один из самых важных и интересных механизмов Java, связанный с компилятором (Compiler). Это фундаментальное различие между временем компиляции и runtime.

1. Что такое стирание типов?

Это процесс, при котором компилятор Java удаляет информацию о generic типах из скомпилированного кода (bytecode). То есть:

// ВЫ пишете (исходный код, compile-time)
List<String> names = new ArrayList<String>();
names.add("John");
names.add("Alice");
String firstName = names.get(0); // Известно, что это String

// КОМПИЛЯТОР преобразует это (bytecode, runtime)
List names = new ArrayList(); // Информация о String удалена!
names.add("John");
names.add("Alice");
String firstName = (String) names.get(0); // Нужна явная типизация

После компиляции информация о <String> полностью исчезает. Runtime не знает, что это List<String>.

2. Почему это связано с КОМПИЛЯТОРОМ?

Стирание типов — это явно работа компилятора, а не runtime:

ПРОЦЕСС КОМПИЛЯЦИИ:

1. Parse (разбор) — компилятор читает исходный код
   List<String> list = new ArrayList<String>();
   
2. Type checking (проверка типов) — компилятор проверяет
   - Проверяет, что String совместим
   - Проверяет, что get() возвращает String
   - ИСПОЛЬЗУЮТСЯ generic типы
   
3. Code generation (генерация кода) — компилятор создаёт bytecode
   - УДАЛЯЕТ информацию о <String>
   - Превращает это в List (raw type)
   - СТИРАЕТ типы
   
4. Javac выводит .class файл с удаленной информацией

3. Подробный пример

// Исходный код (то, что вы пишете)
public class GenericExample {
    public static void main(String[] args) {
        // COMPILE-TIME: компилятор знает это List<String>
        List<String> strings = new ArrayList<String>();
        strings.add("Hello");
        String value = strings.get(0); // Безопасно!
        
        // COMPILE-TIME: компилятор знает это List<Integer>
        List<Integer> integers = new ArrayList<Integer>();
        integers.add(42);
        // strings.add((Object)integers.get(0)); // Ошибка компиляции!
        
        // RUNTIME: на самом деле оба это просто List
        System.out.println(strings.getClass()); // class java.util.ArrayList
        System.out.println(integers.getClass()); // class java.util.ArrayList
        // Идентичные классы!
    }
}

// Скомпилированный bytecode (что получается после javac)
public class GenericExample {
    public static void main(String[] args) {
        List strings = new ArrayList(); // <String> удален!
        strings.add("Hello");
        String value = (String) strings.get(0); // Явная типизация!
        
        List integers = new ArrayList(); // <Integer> удален!
        integers.add(42);
        // strings.add(integers.get(0)); // Теперь это просто Object
    }
}

4. Правила стирания типов

Правило 1: Заменить generic параметры на верхнюю границу

// Без верхней границы — становится Object
public class Box<T> {
    private T value;
    public T getValue() { return value; } // Становится Object getValue()
}

// С верхней границей — становится эта граница
public class NumberBox<T extends Number> {
    private T value;
    public T getValue() { return value; } // Становится Number getValue()
}

compileTime: Box<String> и Box<Integer> — разные
runtime:     Box и Box — идентичные (оба используют Object)

Правило 2: Вставить явные типизации где нужно

public class GenericMethod {
    // Compile-time
    public <T> T getValue(T value) {
        return value; // Возвращает T
    }
    
    // Runtime (после стирания)
    public Object getValue(Object value) {
        return value; // Возвращает Object
    }
}

Правило 3: Генерация bridge методов для наследования

public class Node<T> {
    public T getValue() { return null; }
}

public class StringNode extends Node<String> {
    @Override
    public String getValue() { return "hello"; }
}

// Компилятор создаёт bridge method для совместимости
public class StringNode extends Node {
    public String getValue() { return "hello"; }
    
    // Bridge method (synthetic)
    public Object getValue() { // Для совместимости
        return (Object) getValue(); // Вызывает String версию
    }
}

5. Проблемы, которые вызывает стирание типов

Проблема 1: Нельзя создать экземпляр generic типа

public class GenericArray {
    public <T> T[] createArray(int size) {
        // ОШИБКА КОМПИЛЯЦИИ!
        return new T[size]; // T не существует в runtime!
        
        // Нужно использовать Object или Array.newInstance
        return (T[]) new Object[size]; // Unsafe cast
    }
}

Проблема 2: Нельзя использовать instanceof с generic типами

public void checkType(Object obj) {
    // ОШИБКА КОМПИЛЯЦИИ!
    if (obj instanceof List<String>) { } // Ошибка!
    
    // Работает только без типов
    if (obj instanceof List) { } // OK
    List<?> list = (List<?>) obj;
}

Проблема 3: Нельзя переопределить методы, отличающиеся только типом

public class Test {
    public void print(List<String> list) { } // После стирания: print(List)
    public void print(List<Integer> list) { } // После стирания: print(List)
    // ОШИБКА КОМПИЛЯЦИИ! Методы идентичны в runtime
}

Проблема 4: Невозможно получить generic информацию в runtime

public class ReflectionTest {
    public static void main(String[] args) throws Exception {
        List<String> list = new ArrayList<>();
        
        // Compile-time: это List<String>
        // Runtime: информация потеряна
        
        Class<?> clazz = list.getClass(); // ArrayList
        // Нельзя узнать, что это ArrayList<String>
        // clazz.getTypeParameters(); // Ничего не вернёт
    }
}

6. Как получить информацию о generics (обходной путь)

Эсли вам нужна информация о типах, используйте Type tokens:

// Способ 1: TypeToken из Guava
public class TypeTokenExample {
    public void useTypeToken() {
        TypeToken<List<String>> token = new TypeToken<List<String>>() {};
        // Сохраняет информацию о типе благодаря анонимному классу
    }
}

// Способ 2: Явный Type parameter
public class GenericDAO<T> {
    private final Class<T> type;
    
    public GenericDAO(Class<T> type) {
        this.type = type; // Передаём тип явно
    }
    
    public T findById(Long id) {
        // Теперь можем использовать type
        return type.cast(getFromDatabase(id));
    }
}

// Использование
GenericDAO<User> userDAO = new GenericDAO<>(User.class);
User user = userDAO.findById(1L);

// Способ 3: Рефлексия с ParameterizedType
public class ReflectionHelper {
    public static <T> Type getGenericType(Class<?> clazz) {
        Type type = clazz.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) type;
            return pType.getActualTypeArguments()[0];
        }
        return null;
    }
}

7. Исторический контекст: почему Java выбрала стирание типов?

Это было сделано в Java 1.5 для обратной совместимости:

СЧИТАЕТЕ ГОДЫ JDK:

- Java 1.4 и раньше: нет generics
  List list = new ArrayList(); // Raw type
  list.add("hello");
  String value = (String) list.get(0); // Manual cast

- Java 1.5: добавлены generics
  List<String> list = new ArrayList<>();
  String value = list.get(0); // No cast

- Проблема: старый код использует raw types
  List oldList = ...; // Из старой библиотеки
  List<String> newList = (List<String>) oldList; // Нужна совместимость

- Решение: стирание типов в bytecode
  - Новый код получает type-safety на compile-time
  - Старый code продолжает работать
  - Bytecode совместим в обе стороны

8. Как компилятор использует стирание типов

// Этап 1: Парсинг и проверка типов
public class Compiler {
    // javac читает: List<String>
    // javac проверяет типы
    // javac гарантирует безопасность
}

// Этап 2: Стирание типов
public class TypeErasure {
    public static void main(String[] args) {
        // Нужно удалить <String> из List<String>
        // Для совместимости с JVM
        
        List raw = new ArrayList(); // Удалены типы
    }
}

// Этап 3: Добавление типизаций
public class TypeInsert {
    public static void main(String[] args) {
        Object value = raw.get(0); // Возвращает Object
        String str = (String) value; // Явная типизация
    }
}

9. Практические последствия для разработчика

// Последствие 1: Compile-time проверка защищает
@Service
public class UserService {
    public List<User> getUsers() {
        return List.of(
            new User("Alice"),
            new User("Bob")
        ); // Типы проверены компилятором
    }
}

// Последствие 2: Нельзя получить generic тип в runtime
@Autowired
private ObjectMapper mapper;

public <T> T readValue(String json, Class<T> type) {
    // Class<T> передаётся явно, потому что тип стёрт
    return mapper.readValue(json, type);
}

// Последствие 3: Jackson/Hibernate нужны workarounds
TypeReference<List<User>> typeRef = new TypeReference<List<User>>() {};
List<User> users = mapper.readValue(json, typeRef);
// Анонимный класс сохраняет информацию о типе

Итоговый ответ на собеседовании

"Стирание типов связано с КОМПИЛЯТОРОМ.

Когда вы пишете код с generics:
  List<String> list = new ArrayList<>();

Компилятор делает три вещи:

1. ПРОВЕРКА ТИПОВ (compile-time)
   - Проверяет, что String совместим
   - Гарантирует type-safety

2. СТИРАНИЕ ТИПОВ
   - Удаляет информацию о <String>
   - Превращает в List (raw type)
   - Добавляет явные типизации: (String) list.get(0)

3. ГЕНЕРАЦИЯ BYTECODE
   - JVM не видит <String>
   - JVM получает обычный List
   - Это обеспечивает совместимость

Почему? Для обратной совместимости с Java 1.4 и старше.

Последствия:
- Compile-time type-safe
- Runtime информация потеряна
- Нельзя создать T[], instanceof List<String>
- Нужны workarounds (TypeToken, Class параметр)"

Заключение

Стирание типов — это компилятор удаляет информацию о generic типах, превращая List<String> в List в bytecode. Это обеспечивает:

• Backward compatibility с Java 1.4
• Type-safety на compile-time
• Совместимость JVM

Это фундаментальная концепция Java, которую должен знать каждый серьёзный разработчик.