Перейти на PRO

Для чего используется блок `finally` в Java и приведи пример.

Тип вопроса: Java Core Вероятность: 10% Категория: Java Разработчик

Ответ

Блок finally в Java используется в конструкции try-catch-finally для определения кода, который должен быть выполнен всегда, независимо от того, было ли выброшено исключение в блоке try или нет. Это гарантирует выполнение критически важных операций, таких как освобождение ресурсов (закрытие файлов, соединений с БД).

Ключевые особенности:

  • Блок finally выполняется после блока try и при наличии — после подходящего блока catch.
  • Он выполняется даже если:
    • Исключение было выброшено и перехвачено (catch).
    • Исключение было выброшено и НЕ перехвачено.
    • В блоке try или catch был выполнен return.
    • В блоке try или catch было выброшено необрабатываемое исключение (например, Error).
  • Единственные случаи, когда finally может не выполниться: аварийное завершение JVM (System.exit()) или сбой операционной системы.

Пример 1: Гарантированное закрытие ресурса (до Java 7):

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // ... чтение файла
    int data = fis.read();
} catch (IOException e) {
    System.err.println("Ошибка чтения файла: " + e.getMessage());
} finally {
    // Этот блок выполнится ВСЕГДА
    if (fis != null) {
        try {
            fis.close(); // Гарантированное закрытие потока
        } catch (IOException e) {
            System.err.println("Ошибка при закрытии файла: " + e.getMessage());
        }
    }
    System.out.println("Блок finally выполнен.");
}

Пример 2: finally и return:

public static int testFinally() {
    try {
        System.out.println("Inside try");
        return 1; // Значение запоминается
    } catch (Exception e) {
        return 2;
    } finally {
        System.out.println("Inside finally"); // Выполнится ПЕРЕД возвратом из метода
        // return 3; // Если раскомментировать, метод ВСЕГДА вернет 3!
    }
}

public static void main(String[] args) {
    int result = testFinally();
    System.out.println("Result: " + result);
}
// Вывод:
// Inside try
// Inside finally
// Result: 1

Современная альтернатива (Java 7+): Начиная с Java 7, для автоматического управления ресурсами рекомендуется использовать try-with-resources, который неявно вызывает close() в блоке, аналогичном finally.

// Эквивалентно примеру 1, но короче и безопаснее
try (FileInputStream fis = new FileInputStream("file.txt")) {
    int data = fis.read();
    // ...
} catch (IOException e) {
    System.err.println("Ошибка: " + e.getMessage());
}
// Поток закроется автоматически после выхода из try-блока

Вывод: Блок finally — это фундаментальный механизм для обеспечения надежности кода и предотвращения утечек ресурсов. В современном коде для ресурсов, реализующих AutoCloseable, предпочтительнее использовать try-with-resources.

Ответ 18+ 🔞

А, блядь, ну вот, опять про этот ваш finally заговорили. Ну слушай сюда, сейчас я тебе так объясню, что ты сам от себя офигеешь.

Представь себе, ты такой, в квартиру зашёл, нажрался как свинья, пиццу по столу размазал, пивком всё залил — пиздец бардак, короче. И вот ты уже на пороге стоишь, ключ в замке, щас свалишь и забудешь. А тут голос из подсознания: «А свет-то, мудак, не выключил! И дверь нахуй не закроешь!». Вот этот голос — это и есть блок finally. Он тебя всегда накроет, даже если ты уже в коридоре и руку на ручку положил. Выбросило тебя из квартиры с криком «Всё, я ушёл нахуй!» (return) — всё равно вернёшься свет выключить. Сосед сверху затопил (exception) — всё равно вернёшься, чтоб хоть дверь прикрыть, перед тем как с ним разбираться. Единственное, если дом напрочь ебнулся (System.exit() или ОС сдохла) — ну тогда уже похуй, свет пусть горит.

Раньше, до Java 7, все так и жили, как последние уроды. Откроют файл или соединение к базе, а закрыть-то забывают. И получается овердохуища утечек, всё тормозит, память жрёт. Приходилось писать код, от которого глаза кровоточат:

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
    // ... читаем тут
    int data = fis.read();
} catch (IOException e) {
    System.err.println("Ошибка чтения файла: " + e.getMessage());
} finally {
    // А вот этот кусок — святое. Он выполнится ВСЕГДА.
    if (fis != null) {
        try {
            fis.close(); // Закрываем, блядь, наконец-то!
        } catch (IOException e) {
            System.err.println("Ошибка при закрытии файла: " + e.getMessage());
        }
    }
    System.out.println("Блок finally выполнен.");
}

Видишь эту хуйню? В try работаем, в catch ошибки ловим, а в finally — обязательный финишный штрих, типа «извините за беспокойство, мы убрали за собой». Без него — считай, оставил после себя говно.

А теперь самое интересное — finally и return. Вот тут, блядь, магия начинается. Смотри:

public static int testFinally() {
    try {
        System.out.println("Inside try");
        return 1; // Казалось бы, всё, пиздец, значение 1 уже в кармане!
    } catch (Exception e) {
        return 2;
    } finally {
        System.out.println("Inside finally"); // Ан нет, сука! Сначала Я!
        // return 3; // А если тут свой return впендюрить, то забудь про единицу, вернётся тройка!
    }
}

Запустишь — увидишь: сначала «Inside try», потом «Inside finally», и только потом результат 1. Finally вклинивается прямо перед самым уходом, как наглая тёща. Но если в нём самом написать return — то он перебьёт всё нахуй, и вернёт своё значение. Это как тёща не только свет выключила, но и дверь на новый замок поменяла — возвращайся, мудак, переделывай.

Ну и ладно, хватит про старьё. С Java 7 появилась, блядь, просто сказка — try-with-resources. Это как если бы у тебя был личный дворецкий, который сам всё за тобой приберёт. Выглядит — загляденье:

// Эквивалентно тому пиздецу сверху, но в разы круче
try (FileInputStream fis = new FileInputStream("file.txt")) {
    int data = fis.read();
    // ...
} catch (IOException e) {
    System.err.println("Ошибка: " + e.getMessage());
}
// Поток закроется автоматом, как только try закончится. Вообще без твоего участия.

Вот и весь расклад. Finally — это старый, добрый, надёжный костыль, который всегда прикроет твою жопу. А try-with-resources — это уже как протез с моторчиком, сам всё делает. Но суть одна: в этом мире за собой надо убирать, а то засрут.

© ХакСобесов, 2026
support@hacksobesov.com