Какие плюсы и минусы проверяемых исключений?

Ответ

Определение проверяемых исключений

Проверяемые исключения (Checked Exceptions) — это исключения, которые обязаны быть обработаны при компиляции. Если метод может выбросить проверяемое исключение, он должен либо его обработать (try-catch), либо объявить в сигнатуре (throws). Примеры: IOException, SQLException, FileNotFoundException.

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

• Явность: компилятор заставляет разработчика явно обработать возможные проблемы
• Безопасность на этапе компиляции: неправильная обработка ошибок будет выявлена до production
• Документация: сигнатура метода показывает какие ошибки он может выбросить
• Осознанное программирование: разработчик обязан думать о том, что может пойти не так
• Контрактное соглашение: клиент метода знает, что нужно обработать исключение
• Легче найти нарушения: IDE подсвечивает места, где нужна обработка

Минусы проверяемых исключений

• Необходимость try-catch везде: код становится многословным и сложным для чтения
• Раздувание сигнатур методов: метод пробрасывает 5 различных исключений — сигнатура становится нечитаемой
• Принуждение к обработке необработимых ошибок: не все проверяемые исключения можно разумно обработать локально
• Множественная пробросить: разработчик вынужден пробросить исключение через всю цепочку вызовов
• Нарушение принципа DRY: один и тот же try-catch блок повторяется в разных местах
• Блокирование архитектуры: если нижний слой выбросит новое проверяемое исключение, все слои сверху нужно обновлять
• Наложение на реактивные функции: Stream API и lambda функции плохо работают с проверяемыми исключениями
• Попадание в ловушку закупоривания: разработчик лениво перехватывает все Exception и игнорирует

Проверяемые vs Непроверяемые исключения

// ПРОВЕРЯЕМЫЕ ИСКЛЮЧЕНИЯ (должны быть обработаны)
try {
    Thread.sleep(1000);  // InterruptedException
} catch (InterruptedException e) {
    // Обязательно обработать
}

// НЕПРОВЕРЯЕМЫЕ ИСКЛЮЧЕНИЯ (не обязательно обрабатывать)
String text = null;
int length = text.length();  // NullPointerException — никто не заставляет обрабатывать

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

// ❌ ПЛОХО: многословность
public void processData(String path) throws IOException, SQLException, JSONException {
    try {
        readFile(path);
    } catch (IOException e) {
        throw e;  // Просто пробрасываем дальше
    }
}

// ❌ УЖАСНО в Stream API
List<String> lines = Files.readAllLines(Paths.get("file.txt"))
    .stream()
    .map(line -> {
        try {
            return parseJSON(line);  // IOException не может быть проброшена!
        } catch (IOException e) {
            throw new RuntimeException(e);  // Пришлось обернуть
        }
    })
    .collect(Collectors.toList());

// ✅ Современный стиль (Java 5+)
public void modernWay() {
    try {
        // Непроверяемые исключения для ошибок приложения
        throw new RuntimeException("Что-то пошло не так");
    } catch (Exception e) {
        // Логируем и пробрасываем дальше
        logger.error("Error occurred", e);
        throw new ApplicationException("Processing failed", e);
    }
}

// ✅ Функциональный подход (Java 8+)
List<String> result = files.stream()
    .map(this::safeRead)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

private Optional<String> safeRead(String path) {
    try {
        return Optional.of(Files.readString(Paths.get(path)));
    } catch (IOException e) {
        logger.warn("Failed to read file: {}", path, e);
        return Optional.empty();
    }
}

Вывод

Проверяемые исключения полезны для явной документации и безопасности типов, но они делают код многословным и сложным. Современная Java практика тяготеет к непроверяемым исключениям с логированием и контролем на границах приложения. Используй проверяемые исключения для действительно критических ошибок (IO, сеть), которые не могут быть обработаны локально.