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

Что такое исключение

Исключение — это способ Java сказать «что-то пошло не так, и я не могу продолжать как обычно». Вместо того чтобы возвращать неверное значение или незаметно портить ваши данные, среда выполнения создаёт объект исключения, описывающий проблему, и выбрасывает его. Нормальное выполнение в этой точке останавливается, и Java начинает искать код, который знает, как справиться с ситуацией.

Если никто его не обработает, исключение достигает вершины вашей программы, JVM печатает трассировку стека, и процесс завершается с ненулевым статусом.

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};
        System.out.println("before");
        System.out.println(numbers[5]);   // индекса 5 не существует
        System.out.println("after");      // никогда не выполняется
    }
}

Обратите внимание, что "after" никогда не печатается. В тот миг, когда вычисляется numbers[5], выбрасывается ArrayIndexOutOfBoundsException, и оставшаяся часть main отбрасывается.

Чтение трассировки стека

Когда исключение остаётся необработанным, вы получаете вывод вроде такого. Он выглядит пугающе, но это всего лишь список:

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Main.divide(Main.java:8)
	at Main.main(Main.java:4)

Читайте сверху вниз:

• Первая строка — это тип (ArithmeticException) и сообщение (/ by zero).
• Каждая строка at ... — это кадр стека. Верхний — это место, где исключение действительно было выброшено: divide на строке 8. Под ним вызывающий, main на строке 4.

Верхняя строка at — это то, куда вы смотрите первым делом. Кадры под ней отвечают на вопрос «как мы сюда попали?».

public class Main {
    static int divide(int a, int b) {
        return a / b;            // выбрасывает исключение, когда b равно 0
    }

    public static void main(String[] args) {
        System.out.println(divide(10, 2));
        System.out.println(divide(10, 0));   // бабах
    }
}

Запустите это, и трассировка укажет прямо на строку a / b, а затем покажет main как вызывающего. Эта цепочка вызовов — самый полезный инструмент отладки, который Java даёт вам бесплатно.

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

Каждое исключение — это объект, и все они происходят от Throwable. Две важные ветви:

• Error — серьёзные проблемы, которые поднимает JVM, например OutOfMemoryError или StackOverflowError. Их вы, как правило, не перехватываете.
• Exception — проблемы, которые ваша программа может разумно предвидеть и обработать. Внутри неё находится RuntimeException — родитель повседневных багов вроде NullPointerException.

Throwable
├── Error                 (don't catch: OutOfMemoryError, StackOverflowError)
└── Exception
    ├── IOException        (checked)
    ├── SQLException       (checked)
    └── RuntimeException   (unchecked)
        ├── NullPointerException
        ├── ArithmeticException
        └── ArrayIndexOutOfBoundsException

Поскольку это настоящие классы, исключение может нести сообщение, и вы можете расспросить его о нём самом:

public class Main {
    public static void main(String[] args) {
        try {
            int x = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("type: " + e.getClass().getSimpleName());
            System.out.println("message: " + e.getMessage());
        }
    }
}

getMessage() возвращает текст после двоеточия в трассировке стека; getClass().getSimpleName() даёт вам тип исключения по имени.

Проверяемые и непроверяемые

Это различие сбивает новичков с толку чаще всего.

• Непроверяемые исключения наследуют RuntimeException. Обычно они означают баг в вашем коде — неожиданный null, неверный индекс, деление на ноль. Компилятор не заставляет вас их обрабатывать.
• Проверяемые исключения наследуют Exception, но не RuntimeException (например, IOException). Они представляют условия вне вашего контроля — отсутствующий файл, оборвавшееся сетевое соединение. Компилятор заставляет вас либо перехватить их, либо объявить.

Если метод может выбросить проверяемое исключение, он должен указать это через throws, и каждый вызывающий обязан с ним разобраться:

public class Main {
    // объявляет, что может завершиться проверяемым исключением
    static void risky() throws Exception {
        throw new Exception("something went wrong");
    }

    public static void main(String[] args) throws Exception {
        risky();   // main также должен обработать его или повторно объявить
    }
}

Уберите throws Exception из main, и код даже не скомпилируется — это компилятор обеспечивает соблюдение контракта проверяемых исключений. Непроверяемые исключения этого никогда не требуют.

Выбрасывание собственных исключений

Вы не только реагируете на исключения — вы можете их и поднимать. Используйте throw с новым объектом исключения, чтобы сигнализировать, что аргумент или состояние недопустимы. Это гораздо лучше, чем возвращать магическое значение вроде -1 и надеяться, что вызывающий его проверит.

public class Main {
    static int squareRootInput(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("n must be non-negative, got " + n);
        }
        return n;
    }

    public static void main(String[] args) {
        System.out.println(squareRootInput(16));
        System.out.println(squareRootInput(-4));   // выбрасывает с понятным сообщением
    }
}

Всегда включайте сообщение, объясняющее, что было не так, и в идеале — недопустимое значение: ваше будущее «я», читающее трассировку стека, скажет вам спасибо. IllegalArgumentException и IllegalStateException — два исключения, к которым вы будете обращаться чаще всего при проверке входных данных.

Частые подводные камни

• Проглатывание исключений. Перехват исключения без каких-либо действий (пустой блок) скрывает баги. Как минимум залогируйте его; обычно следует обработать его или пробросить дальше.
• Слишком широкий перехват Exception. Перехват базового Exception (или, хуже того, Throwable) может замаскировать проблемы, которые вы не собирались обрабатывать. Перехватывайте конкретный ожидаемый тип.
• Чтение трассировки снизу вверх. Самый значимый кадр — это верхняя строка at, а не нижняя. Начинайте с неё.
• Путаница между Error и Exception. Не пытайтесь восстановиться после OutOfMemoryError или StackOverflowError; вместо этого устраните первопричину.

Далее: try-catch

Теперь вы знаете, что такое исключения и как их читать. Следующая страница рассказывает, как их на самом деле обрабатывать: оборачивать рискованный код в блок try, восстанавливаться в catch и выполнять код очистки в finally, чтобы ваша программа продолжала работать, а не падала.