Во время компиляции или выполнения кода происходит приведение объекта к его фактическому типу

Когда происходит приведение объекта к фактическому типу

Это вопрос о runtime type casting в Java. Ответ: приведение объекта к его фактическому типу происходит во время выполнения (runtime), а не во время компиляции.

Понимание типов в Java

В Java существует два типа для каждого объекта:

1. Статический тип (Compile-time type) — тип, который знает компилятор
2. Динамический тип (Runtime type) — фактический тип объекта во время выполнения

public class Animal {}
public class Dog extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // Статический тип: Animal
                                    // Динамический тип: Dog
    }
}

Компиляция — проверка статических типов

Во время компиляции Java проверяет статические типы:

Animal animal = new Dog();
Dog dog = (Dog) animal;  // Компилятор разрешит это

// Но это вызовет ошибку компиляции:
String str = (String) animal;  // Хотя синтаксически правильно
// Exception in thread "main" java.lang.ClassCastException

Компилятор НЕ проверяет, что animal действительно Dog. Он только проверяет возможность такого приведения.

Выполнение — проверка динамических типов

Во время выполнения JVM проверяет динамический тип:

public class CastingExample {
    public static void main(String[] args) {
        // Это пройдёт компиляцию
        Object obj = "Hello";  // Динамический тип: String
        
        // Это тоже пройдёт компиляцию
        Integer num = (Integer) obj;  // Но УПАДЁТ во время выполнения!
        // Exception in thread "main" 
        // java.lang.ClassCastException: 
        // java.lang.String cannot be cast to java.lang.Integer
    }
}

Почему это важно

public class TypeExample {
    public static void printType(Object obj) {
        if (obj instanceof String) {
            String str = (String) obj;  // Безопасное приведение
            System.out.println("Строка: " + str);
        } else if (obj instanceof Integer) {
            Integer num = (Integer) obj;  // Безопасное приведение
            System.out.println("Число: " + num);
        }
    }
    
    public static void main(String[] args) {
        printType("Hello");      // Работает
        printType(123);          // Работает
        printType(new Dog());    // Работает
    }
}

Процесс приведения типов

На уровне компиляции:

Animal animal = new Dog();
Dog dog = (Dog) animal;  // Компилятор проверяет:
                         // 1. Animal совместим с Dog?
                         // 2. Используется ли правильный синтаксис?
                         // Если да — OK для компиляции

На уровне выполнения:

Animal animal = new Dog();
Dog dog = (Dog) animal;  // JVM проверяет:
                         // 1. animal действительно типа Dog?
                         // 2. Можно ли привести?
                         // Если нет — ClassCastException

Примеры приведения типов

1. Безопасное приведение (компиляция + выполнение)

public class Dog extends Animal {}

public static void main(String[] args) {
    Dog originalDog = new Dog();
    Animal animal = originalDog;  // Автоматическое приведение вверх (upcasting)
    Dog dog = (Dog) animal;       // Явное приведение вниз (downcasting)
    System.out.println(dog);      // OK!
}

2. Опасное приведение (ошибка выполнения)

public static void main(String[] args) {
    Animal animal = new Animal();  // Динамический тип: Animal
    Dog dog = (Dog) animal;        // Компиляция OK
                                   // Выполнение: ClassCastException!
}

3. Проверка перед приведением

public static void main(String[] args) {
    Object obj = "String value";
    
    // ПЛОХО — может быть исключение
    String str1 = (String) obj;  // OK для этого obj
    
    // ХОРОШО — безопасно
    if (obj instanceof String) {
        String str2 = (String) obj;  // Гарантировано работает
    }
    
    // ОЧЕНЬ ХОРОШО (Java 16+) — pattern matching
    if (obj instanceof String str3) {
        System.out.println(str3);  // str3 уже приведён
    }
}

Иерархия типов

public class Animal {}
public class Dog extends Animal {}
public class Cat extends Animal {}

public class Example {
    public static void main(String[] args) {
        // Upcasting — всегда безопасно (к родителю)
        Dog dog = new Dog();
        Animal animal = dog;  // OK — автоматическое приведение
        
        // Downcasting — нужна проверка (к потомку)
        Animal animal2 = new Dog();
        if (animal2 instanceof Dog) {
            Dog dog2 = (Dog) animal2;  // OK
        }
        
        // Это вызовет ClassCastException
        Cat cat = (Cat) animal2;  // animal2 — это Dog, не Cat
    }
}

Pattern Matching (Java 16+)

public static void processObject(Object obj) {
    // Старый способ
    if (obj instanceof String) {
        String str = (String) obj;
        System.out.println(str.length());
    } else if (obj instanceof Integer) {
        Integer num = (Integer) obj;
        System.out.println(num + 10);
    }
    
    // Новый способ (Java 16+)
    if (obj instanceof String str) {
        System.out.println(str.length());  // str уже приведён
    } else if (obj instanceof Integer num) {
        System.out.println(num + 10);  // num уже приведён
    }
}

Вывод

Компиляция: Java проверяет синтаксис и совместимость типов в иерархии. Компилятор НЕ гарантирует, что приведение будет успешным во время выполнения.

Выполнение: JVM проверяет динамический тип объекта и выполняет фактическое приведение. Если типы не совместимы — выбросит ClassCastException.

Правило: используй instanceof перед приведением типов для безопасности:

if (obj instanceof DesiredType) {
    DesiredType casted = (DesiredType) obj;
    // Используй casted безопасно
}

Ответ на вопрос: приведение объекта к его фактическому типу происходит ВО ВРЕМЯ ВЫПОЛНЕНИЯ (runtime), так как только в этот момент JVM знает настоящий тип объекта.