Для чего нужен блок try-catch-finally?

Для чего нужен блок try-catch-finally?

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

Структура и назначение

try — блок кода, который может выбросить исключение catch — перехватывает и обрабатывает исключение finally — код, который выполняется ВСЕГДА, независимо от исключения

Try блок

try {
    // Код, который может выбросить исключение
    int result = 10 / 0;          // ArithmeticException
    String str = null;
    str.length();                  // NullPointerException
    Integer.parseInt("abc");       // NumberFormatException
}

Тry блок ОБЯЗАТЕЛЕН. Без него не может быть catch или finally.

Catch блок

Catch блок перехватывает и обрабатывает исключения:

try {
    // risky code
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero: " + e.getMessage());
} catch (NullPointerException e) {
    System.out.println("Null reference: " + e.getMessage());
} catch (Exception e) {
    System.out.println("Unknown error: " + e.getMessage());
}

Важно: Порядок catch блоков имеет значение. Более специфичные исключения должны быть ПЕРЕД более общими.

Finally блок

Finally ГАРАНТИРУЕТ выполнение кода:

FileInputStream file = null;
try {
    file = new FileInputStream("data.txt");
    // Read file
} catch (IOException e) {
    System.out.println("File error: " + e.getMessage());
} finally {
    // Выполнится ВСЕГДА, даже если был exception
    if (file != null) {
        try {
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Когда выполняется finally:

• Если не было исключения
• Если было исключение и оно обработано
• Если было исключение и оно НЕ обработано (перед выбросом дальше)
• Даже если в catch есть return

Практический пример: получение данных из API

public User fetchUserData(String userId) {
    HttpConnection connection = null;
    try {
        // Пытаемся получить данные
        connection = createConnection("https://api.example.com/users/" + userId);
        String response = connection.get();
        return parseUser(response);
    } catch (IOException e) {
        // Сетевая ошибка
        logger.error("Network error: " + e.getMessage());
        return new User(); // Default user
    } catch (JsonParseException e) {
        // Ошибка парсинга
        logger.error("Invalid response format: " + e.getMessage());
        return null;
    } finally {
        // ВСЕГДА закрываем connection
        if (connection != null) {
            connection.close();
        }
    }
}

Try-with-resources (Java 7+)

Автоматически закрывает ресурсы (implements AutoCloseable):

// Вместо:
FileInputStream file = null;
try {
    file = new FileInputStream("data.txt");
} finally {
    if (file != null) file.close();
}

// Используем:
try (FileInputStream file = new FileInputStream("data.txt")) {
    // Автоматически закроется после try
}

// Несколько ресурсов:
try (FileInputStream input = new FileInputStream("in.txt");
     FileOutputStream output = new FileOutputStream("out.txt")) {
    // Закроются оба автоматически
    byte[] buffer = new byte[1024];
    // copy data
}

Иерархия исключений

Throwable
├── Exception (checked, должны быть обработаны)
│   ├── IOException
│   ├── SQLException
│   └── ParseException
└── RuntimeException (unchecked)
    ├── NullPointerException
    ├── ArithmeticException
    └── ClassCastException

Checked vs Unchecked

Checked — компилятор требует обработки:

public void readFile(String filename) throws IOException {
    FileInputStream file = new FileInputStream(filename);
}

public void caller() {
    try {
        readFile("data.txt");
    } catch (IOException e) {
        // Обязательно обработать
    }
}

Unchecked — не требует обработки (но можно):

int result = 10 / 0; // ArithmeticException, не требует catch

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // Можем обработать, но не обязательно
}

Примеры использования

Пример 1: Логирование и переброс

try {
    saveUser(user);
} catch (DatabaseException e) {
    logger.error("Failed to save user", e);
    throw new ApplicationException("User save failed", e);
}

Пример 2: Fallback значение

int value = 0;
try {
    value = Integer.parseInt(input);
} catch (NumberFormatException e) {
    logger.warn("Invalid number: " + input);
    value = 0; // Default
}

Пример 3: Cleanup ресурсов

Connection conn = null;
Statement stmt = null;
try {
    conn = getConnection();
    stmt = conn.createStatement();
    // Execute query
} catch (SQLException e) {
    logger.error("Database error", e);
} finally {
    if (stmt != null) stmt.close();
    if (conn != null) conn.close();
}

Важные правила

1. Catch специфичные исключения ПЕРЕД общими

   // Правильно
   catch (FileNotFoundException e) { }
   catch (IOException e) { }
   
   // Неправильно
   catch (IOException e) { }
   catch (FileNotFoundException e) { } // Never reached
   

2. Finally выполняется даже при return в catch

   try {
       return "from try";
   } finally {
       System.out.println("Finally"); // Выполнится!
   }
   

3. Не проглатывай исключения

   // Плохо
   try {
       doSomething();
   } catch (Exception e) {
       // Молчание
   }
   
   // Хорошо
   try {
       doSomething();
   } catch (Exception e) {
       logger.error("Operation failed", e);
       throw e;
   }
   

Отличия от других языков

В Java finally выполняется даже при return/throw, в отличие от многих других языков.

Современный подход (Java 7+)

// Используйте try-with-resources
try (Scanner scanner = new Scanner(file)) {
    while (scanner.hasNextLine()) {
        // Process
    }
} catch (IOException e) {
    logger.error("Error", e);
}

Это автоматически позаботится о закрытии ресурса.

Лучшие практики

1. Обрабатывайте исключения на правильном уровне абстракции
2. Логируйте исключения с достаточной информацией
3. Используйте try-with-resources для управления ресурсами
4. Не проглатывайте исключения
5. Переворачивайте checked исключения в runtime для инфраструктурных ошибок