Почему всегда нужно проверять проверяемые исключения?

Почему всегда нужно проверять проверяемые исключения в Java

Проверяемые исключения (Checked Exceptions) - это явный контракт между методом и его вызывающим кодом. Проверка этих исключений - не просто рекомендация, а залог надежности и безопасности приложения.

Что такое проверяемые исключения

Проверяемые исключения - это исключения, которые компилятор ЗАСТАВЛЯЕТ обрабатывать:

public class CheckedExceptionsExample {
    
    // Проверяемые исключения (Checked) - наследуются от Exception
    // IOException, SQLException, FileNotFoundException и т.д.
    
    // ❌ Ошибка компиляции: не обработана IOException
    // public void readFile() {
    //     FileReader reader = new FileReader("file.txt");
    //     reader.read();
    // }
    
    // ✅ Вариант 1: обработать в try-catch
    public void readFile1() {
        try {
            FileReader reader = new FileReader("file.txt");
            reader.read();
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
    
    // ✅ Вариант 2: пробросить дальше (throws)
    public void readFile2() throws IOException {
        FileReader reader = new FileReader("file.txt");
        reader.read();
    }
    
    // Непроверяемые исключения (Unchecked) - наследуются от RuntimeException
    // NullPointerException, ArrayIndexOutOfBoundsException и т.д.
    
    // ✅ Это допустимо: NullPointerException можно не обрабатывать
    public void useObject(String obj) {
        System.out.println(obj.length());  // Может выбросить NPE
    }
}

Почему компилятор требует проверку

1. Явный контракт метода

public class ExplicitContract {
    
    // Сигнатура точно говорит, какие проблемы могут возникнуть
    public void connectToDatabase(String url) throws SQLException {
        // Вызывающий код ЗНАЕТ, что возможна SQLException
        // Может планировать это в архитектуре
    }
    
    public void callDatabase() {
        try {
            connectToDatabase("jdbc:mysql://localhost");
        } catch (SQLException e) {
            // Точно знаю, что ловить
            logger.error("Database connection failed", e);
            // Могу принять корректное решение: retry, fallback и т.д.
        }
    }
    
    // Без проверяемых исключений:
    public void connectToDatabaseBad(String url) {
        // Неизвестно, какие проблемы могут возникнуть
        // Вызывающий код не может планировать обработку
    }
}

2. Предусмотрение сбоев

public class PredictableFailures {
    
    // Проверяемые исключения явно говорят о предусмотренных сбоях
    public void saveToFile(String data, String filepath) throws IOException {
        // IOException - предусмотренный сбой
        // Файл может быть недоступен, полно место, нет прав и т.д.
        FileWriter writer = new FileWriter(filepath);
        writer.write(data);
        writer.close();
    }
    
    // Непроверяемые исключения - это ошибки программиста
    public void processArray(int[] numbers) {
        // ArrayIndexOutOfBoundsException - ошибка алгоритма
        // Это не предусмотренный сбой, это баг
        System.out.println(numbers[100]);  // numbers имеет только 10 элементов
    }
    
    public static void main(String[] args) {
        PredictableFailures processor = new PredictableFailures();
        
        // Проверяемое исключение НУЖНО обработать
        try {
            processor.saveToFile("data", "/invalid/path/file.txt");
        } catch (IOException e) {
            // Я ЗНАЮ, что возможна IOException
            // И приготовился к ней
        }
        
        // Непроверяемое исключение НЕ обязательно обрабатывать
        // Но это означает баг
        int[] nums = {1, 2, 3};
        processor.processArray(nums);  // Если выбросит исключение - вина программиста
    }
}

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

public class ExceptionHierarchy {
    // Throwable
    //   ├─ Error (критичные ошибки JVM)
    //   │  ├─ OutOfMemoryError
    //   │  ├─ StackOverflowError
    //   │  └─ VirtualMachineError
    //   └─ Exception
    //      ├─ Checked Exception (extends Exception, но не RuntimeException)
    //      │  ├─ IOException
    //      │  ├─ SQLException
    //      │  ├─ FileNotFoundException
    //      │  └─ InterruptedException
    //      └─ Unchecked Exception (extends RuntimeException)
    //         ├─ NullPointerException
    //         ├─ ArrayIndexOutOfBoundsException
    //         ├─ IllegalArgumentException
    //         └─ ArithmeticException
    
    // Примеры Checked Exception
    public void checkedExamples() throws Exception {
        // IOException - файловые операции
        new FileInputStream("file.txt").read();
        
        // SQLException - операции с БД
        // Connection conn = DriverManager.getConnection("jdbc:mysql://localhost");
        
        // InterruptedException - операции с потоками
        Thread.sleep(1000);
    }
}

Последствия игнорирования проверяемых исключений

public class IgnoringCheckedExceptions {
    
    // ❌ ЭТО ОЧЕНЬ ПЛОХО: подавление исключения
    public void readFileIgnored(String filepath) {
        try {
            FileReader reader = new FileReader(filepath);
            reader.read();
        } catch (IOException e) {
            // Молчаливое игнорирование - худший вариант!
            // Программа продолжит работать, но что-то сломается дальше
            // Отладить будет очень сложно
        }
    }
    
    // ❌ ПЛОХО: пробросить как RuntimeException
    public void readFileWrapped(String filepath) {
        try {
            FileReader reader = new FileReader(filepath);
            reader.read();
        } catch (IOException e) {
            // Хотя бы сигнал об ошибке, но теряем информацию
            throw new RuntimeException(e);
        }
    }
    
    // ✅ ХОРОШО: обработать или пробросить
    public void readFileProper1(String filepath) throws IOException {
        FileReader reader = new FileReader(filepath);
        reader.read();
    }
    
    // ✅ ХОРОШО: обработать с логированием
    public boolean readFileProper2(String filepath) {
        try {
            FileReader reader = new FileReader(filepath);
            reader.read();
            return true;
        } catch (IOException e) {
            logger.error("Failed to read file: " + filepath, e);
            return false;
        }
    }
}

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

1. Работа с файлами

public class FileOperations {
    
    public String readFile(String filepath) throws IOException {
        // IOException может возникнуть при:
        // - Файл не найден
        // - Нет прав доступа
        // - Диск отключен
        // - Файл удален во время чтения
        
        StringBuilder content = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader(filepath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
        }  // try-with-resources гарантирует закрытие ресурса
        return content.toString();
    }
    
    public static void main(String[] args) {
        FileOperations ops = new FileOperations();
        try {
            String content = ops.readFile("data.txt");
            System.out.println(content);
        } catch (IOException e) {
            System.err.println("Cannot read file: " + e.getMessage());
            // Берем резервный вариант
            System.out.println("Using default content");
        }
    }
}

2. Работа с сетью

public class NetworkOperations {
    
    public String fetchData(String url) throws IOException {
        // IOException может возникнуть при:
        // - Хост недоступен
        // - Timeout соединения
        // - Соединение разорвано
        // - Нет интернета
        
        try (java.io.InputStream is = new java.net.URL(url).openStream()) {
            return new String(is.readAllBytes());
        }
    }
    
    public static void main(String[] args) {
        NetworkOperations net = new NetworkOperations();
        try {
            String data = net.fetchData("https://api.example.com/data");
            System.out.println(data);
        } catch (IOException e) {
            logger.warn("Failed to fetch data from network", e);
            // Fallback на кэш
            loadFromCache();
        }
    }
    
    private static void loadFromCache() {
        // Используем кэшированные данные
    }
}

3. Работа с БД

public class DatabaseOperations {
    
    public User getUserById(long id) throws SQLException {
        // SQLException может возникнуть при:
        // - БД не доступна
        // - SQL синтаксис ошибка
        // - Нарушение constraint
        // - Таймаут запроса
        
        String query = "SELECT * FROM users WHERE id = ?";
        try (java.sql.Connection conn = getConnection();
             java.sql.PreparedStatement stmt = conn.prepareStatement(query)) {
            stmt.setLong(1, id);
            java.sql.ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                return mapUser(rs);
            }
        }
        return null;
    }
    
    private java.sql.Connection getConnection() throws SQLException {
        return null;  // Stub
    }
    
    private User mapUser(java.sql.ResultSet rs) {
        return null;  // Stub
    }
}

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

public class BestPractices {
    
    // ✅ ХОРОШО: Пробросить дальше, если не можете обработать
    public void processUserData(String filepath) throws IOException {
        // Пробрасываем IOException выше - слой выше знает, как обработать
        String data = readFile(filepath);
        parseData(data);
    }
    
    // ✅ ХОРОШО: Обработать с логированием
    public void saveUserData(String filepath, String data) {
        try {
            writeFile(filepath, data);
        } catch (IOException e) {
            logger.error("Failed to save user data to " + filepath, e);
            // Сообщаем пользователю об ошибке
            notifyUserOfError("Failed to save data");
        }
    }
    
    // ✅ ХОРОШО: Обработать и вернуть результат
    public Optional<String> tryReadFile(String filepath) {
        try {
            return Optional.of(readFile(filepath));
        } catch (IOException e) {
            logger.warn("Cannot read file: " + filepath, e);
            return Optional.empty();
        }
    }
    
    private String readFile(String filepath) throws IOException {
        return null;  // Stub
    }
    
    private void writeFile(String filepath, String data) throws IOException {
        // Stub
    }
    
    private void notifyUserOfError(String message) {
        // Stub
    }
}

Обобщение

Вывод

Проверяемые исключения нужно ВСЕГДА проверять потому что:

1. Контракт - метод обещает, какие проблемы могут возникнуть
2. Надежность - приложение может корректно обработать сбой
3. Отладка - легче найти места обработки ошибок
4. Безопасность - гарантия, что критичные операции обработаны
5. Масштабируемость - код легче расширять и поддерживать

Игнорирование проверяемых исключений - это путь к хрупким, непредсказуемым приложениям с невозможной отладкой.