Что вернет метод при делении на 0 в try, если блок catch возвращает ошибку, а finally возвращает "finally"

Приоритет return в try-catch-finally

Краткий ответ

finally блок ПЕРЕОПРЕДЕЛЯЕТ результат из catch блока. Если finally возвращает значение, это значение будет возвращено метором, игнорируя return из catch.

Визуализация проблемы

public String example() {
    try {
        int result = 10 / 0;  // ArithmeticException
    } catch (Exception e) {
        return "Error from catch";  // Подготовили результат
    } finally {
        return "Finally";  // ПЕРЕОПРЕДЕЛИТ результат!
    }
}

// Результат: "Finally"
// catch значение было проигнорировано!

Детальное объяснение

Порядок выполнения:

1. try блок
   └─ ArithmeticException выброшено
   
2. catch блок
   └─ Поймали исключение
   └─ Выполнен return "Error from catch"
   └─ Метод ГОТОВИЛСЯ вернуть это значение
   
3. finally блок
   └─ ВСЕГДА выполняется (даже если return в catch)
   └─ Выполнен return "Finally"
   └─ ЭТО ПЕРЕОПРЕДЕЛИТ return из catch
   └─ Вернулось "Finally"

Практический пример

public String testFinally() {
    try {
        return "from try";
    } finally {
        return "from finally";  // Переопределит!
    }
    // Результат: "from finally"
}

public String testExceptionAndFinally() {
    try {
        int x = 1 / 0;  // Исключение
        return "from try";  // Никогда не выполнится
    } catch (Exception e) {
        return "from catch";  // Будет подготовлен
    } finally {
        return "from finally";  // ПЕРЕОПРЕДЕЛИТ catch
    }
    // Результат: "from finally"
}

Именно для твоего примера

public String yourExample() {
    try {
        return 10 / 0;  // ← ArithmeticException
    } catch (Exception e) {
        return "error";  // Хотели вернуть это
    } finally {
        return "finally";  // ← ПЕРЕОПРЕДЕЛИТ!
    }
}

// Вызов:
String result = yourExample();
System.out.println(result);  // Выведет: "finally"

Почему это опасно

Это очень частая ошибка, которая скрывает исключения:

// ❌ Плохо!
public User getUserById(Long id) {
    try {
        return userRepository.findById(id).orElseThrow();
    } catch (Exception e) {
        log.error("Error fetching user", e);
        return null;  // Мы хотели вернуть null при ошибке
    } finally {
        return defaultUser();  // ← ЗАБЫЛИ! Это переопределит null
    }
    // Результат: ВСЕГДА возвращает defaultUser()
    // Даже если была ошибка! Логирование потеряется!
}

Правильное использование finally

finally НЕ должен содержать return:

// ✅ Правильно!
public User getUserById(Long id) {
    try {
        return userRepository.findById(id).orElseThrow();
    } catch (Exception e) {
        log.error("Error fetching user", e);
        return null;
    } finally {
        // Очистка ресурсов, без return
        closeConnections();
        flushBuffer();
    }
}

Try-with-resources (современный подход)

Избегай finally вообще:

// ✅ Современный вариант (Java 7+)
public String readFile(String filename) {
    try (BufferedReader reader = new BufferedReader(
        new FileReader(filename))) {
        return reader.readLine();
    } catch (IOException e) {
        return "Error: " + e.getMessage();
    }
    // Ресурсы закроются автоматически, без finally!
}

Что происходит с finally и исключениями

finally выполнится, даже если return выбросит новое исключение:

public String complexCase() {
    try {
        throw new RuntimeException("Original error");
    } catch (Exception e) {
        return "Caught error";  // Подготовили return
    } finally {
        // Это выполнится
        System.out.println("Finally block");
        throw new RuntimeException("New error from finally");  
        // ← Это ПЕРЕОПРЕДЕЛИТ исходную ошибку!
    }
}

// Результат: новое исключение из finally
// Оригинальная ошибка потеряется!

Таблица приоритетов

Что значит в твоём примере

public String yourCase() {
    try {
        return 10 / 0;  // ArithmeticException
    } catch (Exception e) {
        return "error";  // ← Здесь хотели вернуть
    } finally {
        return "finally";  // ← ЭТО ПОБЕДИТ
    }
}

// Поток выполнения:
// 1. try: деление на 0 → исключение
// 2. catch: поймали, return "error" готов
// 3. finally: ВСЕГДА выполняется, return "finally" ПЕРЕОПРЕДЕЛИТ
// 4. Метод вернул: "finally"
// 5. catch return потерян!

Как это выглядит в bytecode

// Компилятор генерирует примерно:
public String example() {
    String result = null;
    try {
        result = "from try";
        return result;  // Сохранён результат
    } catch (Exception e) {
        result = "from catch";
        return result;  // Сохранён результат
    } finally {
        result = "from finally";
        return result;  // ← ПЕРЕОПРЕДЕЛЯЕТ!
    }
}

Правило: finally для cleanup, не для logic

// ❌ НИКОГДА не делай так
public int getNumber() {
    try {
        return 1;
    } finally {
        return 2;  // Переопределит!
    }
    // Вернёт 2, не 1!
}

// ✅ finally только для очистки
public int getNumber() {
    try {
        return 1;
    } finally {
        closeResources();  // Cleanup, БЕЗ return
    }
}

Выводы

✓ finally ВСЕГДА выполняется

✓ Если finally содержит return, он ПЕРЕОПРЕДЕЛИТ return из try/catch

✓ Если finally выбросит исключение, оригинальное исключение потеряется

✓ Никогда НЕ возвращай значение из finally

✓ Используй finally только для очистки ресурсов

✓ Предпочитай try-with-resources (Java 7+) вместо finally

Для твоего примера: Вернётся "finally", потому что finally блок переопределяет return из catch блока.