Ошибки в php и обработка исключений

Проброс исключения

В примере выше мы использовали для обработки некорректных данных. А что, если в блоке возникнет другая неожиданная ошибка? Например, программная (неопределённая переменная) или какая-то ещё, а не ошибка, связанная с некорректными данными.

Пример:

Конечно, возможно все! Программисты совершают ошибки. Даже в утилитах с открытым исходным кодом, используемых миллионами людей на протяжении десятилетий – вдруг может быть обнаружена ошибка, которая приводит к ужасным взломам.

В нашем случае предназначен для выявления ошибок, связанных с некорректными данными. Но по своей природе получает все свои ошибки из . Здесь он получает неожиданную ошибку, но всё также показывает то же самое сообщение . Это неправильно и затрудняет отладку кода.

К счастью, мы можем выяснить, какую ошибку мы получили, например, по её свойству :

Есть простое правило:

Блок должен обрабатывать только те ошибки, которые ему известны, и «пробрасывать» все остальные.

Техника «проброс исключения» выглядит так:

Блок получает все ошибки.
В блоке мы анализируем объект ошибки .
Если мы не знаем как её обработать, тогда делаем .

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

Ошибка в строке из блока «выпадает наружу» и может быть поймана другой внешней конструкцией (если есть), или «убьёт» скрипт.

Таким образом, блок фактически обрабатывает только те ошибки, с которыми он знает, как справляться, и пропускает остальные.

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

Здесь знает только, как обработать , тогда как внешний блок знает, как обработать всё.

Вызов ошибок с помощью оператора throw

До сих пор мы видели ошибки, которые автоматически генерируются парсером JavaScript. Тем не менее, также можно вызвать ошибку вручную с помощью оператора .

Общий синтаксис оператора :

Выражение может быть объектом или значением любого типа данных. Однако лучше использовать объекты, желательно со свойствами и . Встроенный в JavaScript конструктор предоставляет удобный способ создания объекта ошибки. Давайте посмотрим на некоторые примеры:

Если вы используете встроенные в JavaScript функции конструктора ошибок (например, , и т. д.) для создания объектов ошибок, тогда свойство совпадает с именем конструктора, а равно аргументу функции конструктора.

Теперь мы собираемся создать функцию , чтобы найти квадратный корень числа. Это можно сделать просто с помощью встроенной в JavaScript функции , но проблема здесь в том, что она возвращает для отрицательных чисел, не давая никаких подсказок о том, что пошло не так.

Мы собираемся исправить эту проблему, показывая пользователю ошибку, если указано отрицательное число.

Теоретически можно вычислить квадратный корень из отрицательного числа, используя мнимое число , где i2 = -1. Следовательно, квадратный корень из равен , квадратный корень из равен и так далее. Но мнимые числа не поддерживаются в JavaScript.

Генерация собственных ошибок

Что если синтаксически корректен, но не содержит необходимого свойства ?

Например, так:

Здесь выполнится без ошибок, но на самом деле отсутствие свойства для нас ошибка.

Для того, чтобы унифицировать обработку ошибок, мы воспользуемся оператором .

Оператор генерирует ошибку.

Синтаксис:

Технически в качестве объекта ошибки можно передать что угодно. Это может быть даже примитив, число или строка, но всё же лучше, чтобы это был объект, желательно со свойствами и (для совместимости со встроенными ошибками).

В JavaScript есть множество встроенных конструкторов для стандартных ошибок: , , , и другие. Можно использовать и их для создания объектов ошибки.

Их синтаксис:

Для встроенных ошибок (не для любых объектов, только для ошибок), свойство – это в точности имя конструктора. А свойство берётся из аргумента.

Например:

Давайте посмотрим, какую ошибку генерирует :

Как мы видим, это .

В нашем случае отсутствие свойства – это ошибка, ведь пользователи должны иметь имена.

Сгенерируем её:

В строке оператор генерирует ошибку с сообщением . Точно такого же вида, как генерирует сам JavaScript. Выполнение блока немедленно останавливается, и поток управления прыгает в .

Теперь блок становится единственным местом для обработки всех ошибок: и для и для других случаев.

Introduction to the PHP try…catch statement

In programming, unexpected errors are called exceptions. Exceptions can be attempting to read a file that doesn’t exist or connecting to the database server that is currently down.

Instead of halting the script, you can handle the exceptions gracefully. This is known exception handling.

To handle the exceptions, you use the statement. Here’s a typical syntax of the statement:

In this syntax, the statement has two blocks: and .

In the block, you do some tasks e.g.,reading a file. If an exception occurs, the execution jumps to the block.

In the block, you specify the exception name and the code to handle a specific exception.

Error

Добавлено в PHP7 для обработки фатальных ошибок. То есть многие из ошибок, которые раньше приводили к Fatal Error, в PHP7 могут обрабатываться в блоках try/catch. Эти ошибки вызываются самим PHP, неи нужды их вызывать, как Exception. Класс Error имеет три подкласса:

ParseError

Для ошибок парсинга, когда подключаемый по include/require код вызывает ошибку синтаксиса, ошибок функции eval() и т.п.

Пример:

try {
    require 'file-with-syntax-error.php';
} catch (ParseError $e) {
    // обработка ошибки
}

TypeError

Используется для ошибок несоответствия типов данных. В PHP7 введена опциональная строгая типизация. Вот для поддержки ошибок, связанных с ней, и служит этот класс. Например, если функция ожидает на входе аргумент типа int, а вы ее вызываете со строковым аргументом.

Конечно, часто несколько видов ошибок подходят под ситуацию. В этом случае попытайтесь выбрать ту, которая наиболее точно описывает неполадку, ну и которую потом будет проще отлаживать.

Проброс исключения

Пример:

К счастью, мы можем выяснить, какую ошибку мы получили, например, по её свойству :

Есть простое правило:

Блок должен обрабатывать только те ошибки, которые ему известны, и «пробрасывать» все остальные.

Техника «проброс исключения» выглядит так:

Блок получает все ошибки.
В блоке мы анализируем объект ошибки .
Если мы не знаем как её обработать, тогда делаем .

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

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

Здесь знает только, как обработать , тогда как внешний блок знает, как обработать всё.

Определение пользовательских исключений

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

Учитывая, что класс Exception является базовым классом для всех исключений, мы можем, расширив класс Exception, определить свое настраиваемое исключение. Пользовательский класс исключений наследует все свойства и методы класса Exception PHP. Давайте посмотрим на следующий пример, в котором добавим свои собственные методы в собственный класс исключений:

Пример

Попробуй сам

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

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

Как и в других языках, PHP имеет механизм исключений для обработки пользовательских ошибок. Исключение — это сигнал, указывающий на то, что что-то в процессе отличается от предполагаемого хода событий. Исключения могут быть вызваны различными причинами, обычно в случае ошибки, которые проявляются или могут быть специально созданы программой. В большинстве случаев подобные ситуации требуют выполнения специальных инструкций, чтобы предотвратить неконтролируемое завершение процесса.

Многие функции и классы PHP создают исключения.

Пользовательские функции и классы также могут вызывать исключения.

Сохранение сведений об ошибках в состоянии приложения

Как и любые другие данные, ошибки и сообщения об ошибках могут меняться, поэтому их имеет смысл помещать в состояние компонентов. При монтировании компонента данные об ошибке сбрасываются, поэтому, когда пользователь впервые видит страницу, там сообщений об ошибках не будет.

Следующее, с чем надо разобраться, заключается в том, что ошибки одного типа нужно показывать в одном стиле. По аналогии с сервером, здесь можно выделить 3 типа ошибок.

Глобальные ошибки — в эту категорию попадают сообщения об ошибках общего характера, приходящие с сервера, или ошибки, которые, например, возникают в том случае, если пользователь не вошёл в систему и в других подобных ситуациях.
Специфические ошибки, выдаваемые серверной частью приложения — сюда относятся ошибки, сведения о которых приходят с сервера. Например, подобная ошибка возникает, если пользователь попытался войти в систему и отправил на сервер имя и пароль, а сервер сообщил ему о том, что пароль неправильный. Подобные вещи в клиентской части приложения не проверяются, поэтому сообщения о таких ошибках должны приходить с сервера.
Специфические ошибки, выдаваемые клиентской частью приложения. Пример такой ошибки — сообщение о некорректном адресе электронной почты, введённом в соответствующее поле.

Ошибки второго и третьего типов очень похожи, работать с ними можно, используя хранилище состояния компонентов одного уровня. Их главное различие заключается в том, что они исходят из разных источников. Ниже, анализируя код, мы посмотрим на работу с ними.

Здесь будет использоваться встроенная в React система управления состоянием приложения, но, при необходимости, вы можете воспользоваться и специализированными решениями для управления состоянием — такими, как MobX или Redux.

Когда используются исключения?

Исключения используются, когда результат операции отличается от того, что ожидало ваше приложение. К примеру, если ваше приложение пытается прочитать CSV-файл на сервере, а этого файла не существует, то можно сгенерировать исключение. Использование PHP try catch в примере:

В приведенном выше примере использования в PHP try exception мы генерируем исключение тогда, когда не можем открыть запрашиваемый файл. И генерируем мы его, так как файл должен был существовать. Примеры ситуаций, когда вы можете генерировать исключения:

Ваше PHP-приложение не может подключиться к MySQL ;
Ошибка при запросе к базе данных;
Ошибка при запросе к API ;
Получен некорректный тип запроса;
Отсутствуют необходимые переменные $_POST или $_GET .

Нужно ли перехватывать все исключения?

Лично я так не считаю. К примеру: вам не удается подключиться к базе данных, и генерируется исключение, нужно ли тогда исполнять весь оставшийся код? Если весь последующий код привязан к базе данных, которой просто не существует, то зачем же его исполнять?

По моему мнению, исключения нужно перехватывать с помощью PHP try catch finally только, если это не оказывает негативного влияния на остальные функции приложения.

Например: если API-запрос к внешнему сервису выдает ошибку, то вы можете перехватить исключение и вывести дружественное пользователю сообщение « Невозможно подключиться к базе данных » или « Информация о погоде недоступна ».

Не перехваченные исключения следует обрабатывать с помощью пользовательского обработчика. Так вы сможете обрабатывать не перехваченные исключения, и выводить понятные человеку сообщения или заглушки.

Данная публикация представляет собой перевод статьи « Php Exceptions: Try & Catch » , подготовленной дружной командой проекта Интернет-технологии.ру

Применение оператора try…catch

Оператор обработки исключений обычно применяется в следующих ситуациях:

Для некоторого участка кода, в котором может возникнуть ошибка;
Для валидации (проверки) данных перед отправкой на сервер;
Для использования в сложных случаях при написании кроссбраузерных приложений.

Теперь давайте рассмотрим, что же произойдет в сценарии на JavaScript при возникновении ошибки и для чего нужен оператор .

Если в сценарии на языке JavaScript появится ошибка, то дальнейшее выполнение программы будет прекращено. Т.е. инструкции (операторы), которые идут после ошибки выполняться не будут. Но если нам необходимо выполнение программы не прерывать, а переходить к следующей инструкции после той, где может возникнуть ошибка, то эту инструкцию необходимо заключить в оператор «».

Оператор try…catch

JavaScript предоставляет оператор , чтобы перехватывать ошибки времени выполнения и корректно их обработать.

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

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

Следующий пример демонстрирует, как работает оператор :

Приведенный выше скрипт генерирует ошибку, которая отображается в диалоговом окне с предупреждением, а не выводится в консоль браузера. Кроме того, программа не остановилась внезапно, даже если произошла ошибка.

Также обратите внимание, что за ключевым словом указывается идентификатор в скобках. Этот идентификатор действует как параметр функции

При возникновении ошибки интерпретатор JavaScript генерирует объект, содержащий сведения о нем. Этот объект ошибки затем передается в качестве аргумента для обработки.

Оператор является механизмом обработки исключений. Исключением является сигнал, который указывает, что во время выполнения программы возникли какие-то исключительные условия или ошибки. Термины «исключение» и «ошибка» часто используются взаимозаменяемо.

try…catch…finally

Подождите, это ещё не всё.

Конструкция может содержать ещё одну секцию: .

Если секция есть, то она выполняется в любом случае:

после , если не было ошибок,
после , если ошибки были.

Расширенный синтаксис выглядит следующим образом:

Попробуйте запустить такой код:

У кода есть два пути выполнения:

Если вы ответите на вопрос «Сгенерировать ошибку?» утвердительно, то .
Если ответите отрицательно, то .

Секцию часто используют, когда мы начали что-то делать и хотим завершить это вне зависимости от того, будет ошибка или нет.

Например, мы хотим измерить время, которое занимает функция чисел Фибоначчи . Естественно, мы можем начать измерения до того, как функция начнёт выполняться и закончить после. Но что делать, если при вызове функции возникла ошибка? В частности, реализация в коде ниже возвращает ошибку для отрицательных и для нецелых чисел.

Секция отлично подходит для завершения измерений несмотря ни на что.

Здесь гарантирует, что время будет измерено корректно в обеих ситуациях – и в случае успешного завершения и в случае ошибки:

Вы можете это проверить, запустив этот код и введя в – код завершится нормально, выполнится после . А затем введите – незамедлительно произойдёт ошибка, выполнение займёт . Оба измерения выполняются корректно.

Другими словами, неважно как завершилась функция: через или. Секция срабатывает в обоих случаях

Переменные внутри локальны

Обратите внимание, что переменные и в коде выше объявлены до. Если переменную объявить в блоке, например, в , то она не будет доступна после него

Если переменную объявить в блоке, например, в , то она не будет доступна после него.

Блок срабатывает при любом выходе из , в том числе и .

В примере ниже из происходит , но получает управление до того, как контроль возвращается во внешний код.

Конструкция без секции также полезна. Мы применяем её, когда не хотим здесь обрабатывать ошибки (пусть выпадут), но хотим быть уверены, что начатые процессы завершились.

В приведённом выше коде ошибка всегда выпадает наружу, потому что тут нет блока . Но отрабатывает до того, как поток управления выйдет из функции.

Использование блоков try/catch/finally для восстановления после ошибок или высвобождения ресурсов

Используйте блоки /, выделив с их помощью код, который потенциально может явиться источником исключения, таким образом можно будет выполнить восстановление кода после возникновения этого исключения. В блоках следует всегда упорядочивать исключения от более производных к менее производным. Все исключения, производные от Exception. Более производные исключения не обрабатываются предложением catch, которому предшествует предложение catch для базового класса исключения. Если ваш код не удается восстановить после возникновения исключения, не перехватывайте это исключение. Включите методы выше по стеку вызовов для восстановления по мере возможности.

Очистите ресурсы, выделенные с помощью инструкций или блоков . Рекомендуется использовать инструкции для автоматической очистки ресурсов при возникновении исключений. Используйте блоки , чтобы очистить ресурсы, которые не реализуют IDisposable. Код в предложении выполняется почти всегда — даже при возникновении исключений.

Как использовать исключения

Исключения реализуются также как и любой другой объект:

$exception = new Exception();
throw $exception;

Так же как и любой объект, они имеют методы, которые можно вызвать. Данные методы облегчают формирование реакции на исключение. Например, функция позволяет получить сообщение об ошибке, которое может быть записано в журнал или выведено в браузер.

Вот список методов исключений:

– получает сообщение исключения;
– возвращает числовой код, который представляет исключение;
– возвращает файл, в котором произошло исключение;
– возвращает номер строки в файле, где произошло исключение;
– возвращает массив backtrace() до возникновения исключения;
– возвращает исключение, произошедшее перед текущим, если оно было;
– возвращает массив backtrace() исключения в виде строки;
–возвращает все исключение в виде строки. Данную функцию можно переписать.

Для лучшей иллюстрации методов, создадим класс , который осуществляет базовое управление записями пользователей:

В данном примере имеется несколько мест, где может проявиться исключение. Для начала, $user_id в нашей функции должен иметь тип integer. Если события сложатся по другому, то нужно генерировать исключение:

...
...
...
private static function _getUserRecord($user_id)
{
   $user_id = self::_validateUserId($user_id);
   ...
   ...
   ...
}
 
private static function _validateUserId($user_id)
{
   if( !is_numeric($user_id) && $user_id != 'error' ) {
      throw new Exception('Ой! Здесь что-то не так с идентификатором пользователя');
   }
   return $user_id;
}

Теперь попробуем создать пользователя с неправильным идентификатором:

Использование «try…catch»

Давайте рассмотрим реальные случаи использования .

Как мы уже знаем, JavaScript поддерживает метод JSON.parse(str) для чтения JSON.

Обычно он используется для декодирования данных, полученных по сети, от сервера или из другого источника.

Мы получаем их и вызываем вот так:

Вы можете найти более детальную информацию о JSON в главе Формат JSON, метод toJSON.

Если некорректен, генерирует ошибку, то есть скрипт «падает».

Устроит ли нас такое поведение? Конечно нет!

Получается, что если вдруг что-то не так с данными, то посетитель никогда (если, конечно, не откроет консоль) об этом не узнает. А люди очень не любят, когда что-то «просто падает» без всякого сообщения об ошибке.

Давайте используем для обработки ошибки:

Здесь мы используем блок только для вывода сообщения, но мы также можем сделать гораздо больше: отправить новый сетевой запрос, предложить посетителю альтернативный способ, отослать информацию об ошибке на сервер для логирования, … Всё лучше, чем просто «падение».

Блок finally

При обработке
ошибок часто используется еще один необязательный блок finally, который
выполняется в любом случае: возникли ошибки или нет, причем, в последнюю
очередь. Зачем он может понадобиться? Например, чтобы выполнить некоторые
обязательные действия после завершения соединения с сервером:

Мы здесь
определяем некоторый флаг (flSend) для определения выполнения
текущего запроса и если он установлен в true, то запрос
второй раз отправляться не будет. Соответственно, потом, после успешной или
ошибочной обработки, этот флаг обязательно нужно вернуть в значение false. Как раз это и
делается в блоке finally.

Атака: Перезапись SEH

Подобно атакам ret2libc, перезапись SEH (структурированного обработчика исключений) — это атака, связанная с перезаписью указателя так, чтобы он вёл на другую функцию. Однако в то время как атаки ret2libc были основаны на перезаписи указателя возврата для перенаправления программы на определенную функцию libc, перезапись SEH влияет на функцию, изменяя указатель обработчика исключения, а затем вызывает исключение, чтобы программа перешла к выполнению нашей вредоносной функции.

Вы можете провести аналогию с махинациями со страховками:

Подобно мошенничеству со страховкой Боба, перезапись SEH заставляет обработчик исключений переходить к программе злоумышленника, а не обрабатывать исключение должным образом. Такая атака может быть направлена на уязвимости форматированной строки или на переполнение буфера стека, поскольку указатель обработчика исключений — это просто адрес, который хранится в стеке. Чтобы воспользоваться уязвимостью, злоумышленнику потребуется перезаписать указатель обработчика исключения, указав на вредоносную программу, а не на фактический обработчик исключения. Затем пользователю потребуется вызвать исключение. Как только это исключение будет перехвачено, оно будет перенаправлено на вредоносную функцию, которая сможет отбросить исключение и выполнить своё назначение.

Перезапись SEH

Методы обработки ошибок[править]

1. Не обрабатывать.

2. Коды возврата. Основная идея — в случае ошибки возвращать специальное значение, которое не может быть корректным. Например, если в методе есть операция деления, то придется проверять делитель на равенство нулю. Также проверим корректность аргументов и :

Double f(Double a, Double b) {
     ((a == ) || (b == )) {
        ;
    }
    
     (Math.abs(b) < ) {
        ;    
    }  {
         a / b;
    }
}

При вызове метода необходимо проверить возвращаемое значение:

Double d = f(a, b); 
 (d != ) {
    
}  {
    
}

Минусом такого подхода является необходимость проверки возвращаемого значения каждый раз при вызове метода. Кроме того, не всегда возможно определить тип ошибки.

3.Использовать флаг ошибки: при возникновении ошибки устанавливать флаг в соответствующее значение:

 ;

Double f(Double a, Double b) {
     ((a == ) || (b == )) {
         = ;
        ;
    }
    
     (Math.abs(b) < ) {
         = ;
         b;    
    }  {
         a / b;
    }
}

 = ;
Double d = f(a, b); 
 () {
    
}  {
    
}

Минусы такого подхода аналогичны минусам использования кодов возврата.

4.Можно вызвать метод обработки ошибки и возвращать то, что вернет этот метод.

Double f(Double a, Double b) {
      ((a == ) || (b == )) {
          nullPointer();
     }
     
      (Math.abs(b) < ) {
          divisionByZero();    
     }  {
          a / b;
     }
 }

Но в таком случае не всегда возможно проверить корректность результата вызова основного метода.

5.В случае ошибки просто закрыть программу.

 (Math.abs(b) < ) {
    System.exit();
    ;    
}

Это приведет к потере данных, также невозможно понять, в каком месте возникла ошибка.

Обработка исключений[править]

Чтобы сгенерировать исключение используется ключевое слово . Как и любой объект в Java, исключения создаются с помощью .

 (t == ) {
     NullPointerException();
}

Есть два стандартных конструктора для всех исключений: первый — конструктор по умолчанию, второй принимает строковый аргумент, поэтому можно поместить подходящую информацию в исключение.

Возможна ситуация, когда одно исключение становится причиной другого. Для этого существует механизм exception chaining. Практически у каждого класса исключения есть конструктор, принимающий в качестве параметра – причину исключительной ситуации. Если же такого конструктора нет, то у есть метод , который можно вызвать один раз, и передать ему исключение-причину.

Как и было сказано раньше, определение метода должно содержать список всех проверяемых исключений, которые метод может бросить. Также можно написать более общий класс, среди наследников которого есть эти исключения.

 f()  InterruptedException, IOException {

try-catch-finallyправить

Код, который может бросить исключения оборачивается в -блок, после которого идут блоки и (Один из них может быть опущен).

 {
    
}

Сразу после блока проверки следуют обработчики исключений, которые объявляются ключевым словом catch.

 {
    
} (Type1 id1) {
    
} (Type2 id2) {
    
}

-блоки обрабатывают исключения, указанные в качестве аргумента. Тип аргумента должен быть классом, унаследованного от , или самим . Блок выполняется, если тип брошенного исключения является наследником типа аргумента и если это исключение не было обработано предыдущими блоками.

Код из блока выполнится в любом случае: при нормальном выходе из , после обработки исключения или при выходе по команде .

NB: Если JVM выйдет во время выполнения кода из или , то -блок может не выполниться. Также, например, если поток выполняющий или код остановлен, то блок может не выполниться, даже если приложение продолжает работать.

Блок удобен для закрытия файлов и освобождения любых других ресурсов. Код в блоке должен быть максимально простым. Если внутри блока будет брошено какое-либо исключение или просто встретится оператор , брошенное в блоке исключение (если таковое было брошено) будет забыто.

 java.io.IOException;

 ExceptionTest {
   
     main(String[] args) {
         {
             {
                Exception();
            }  {
                 IOException();
            }
        }  (IOException ex) {
            System..println(ex.getMessage());
        }  (Exception ex) {
            System..println(ex.getMessage());
        }
    }
}

После того, как было брошено первое исключение — — будет выполнен блок , в котором будет брошено исключение , именно оно будет поймано и обработано. Результатом его выполнения будет вывод в консоль . Исходное исключение теряется.

Обработка исключений, вызвавших завершение потокаправить

При использовании нескольких потоков бывают ситуации, когда поток завершается из-за исключения. Для того, чтобы определить с каким именно, начиная с версии Java 5 существует интерфейс . Его реализацию можно установить нужному потоку с помощью метода . Можно также установить обработчик по умолчанию с помощью статического метода .

Интерфейс имеет единственный метод , в который передается экземпляр потока, завершившегося исключением, и экземпляр самого исключения. Когда поток завершается из-за непойманного исключения, JVM запрашивает у потока , используя метод , и вызвает метод обработчика – . Все исключения, брошенные этим методом, игнорируются JVM.

Информация об исключенияхправить

. Этот метод возвращает строку, которая была первым параметром при создании исключения;
возвращает исключение, которое стало причиной текущего исключения;
печатает stack trace, который содержит информацию, с помощью которой можно определить причину исключения и место, где оно было брошено.

Exception in thread "main" java.lang.IllegalStateException: A book has a null property
        at com.example.myproject.Author.getBookIds(Author.java:38)
        at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
Caused by: java.lang.NullPointerException
        at com.example.myproject.Book.getId(Book.java:22)
        at com.example.myproject.Author.getBookIds(Author.java:35)

Все методы выводятся в обратном порядке вызовов. В примере исключение было брошено в методе , который был вызван в . «Caused by» означает, что исключение является причиной .

Конструкция try…catch…finally

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

Важно понять, что выполнится в любом случае перед выходом из конструкции , то есть эта особенность пригодится для обработки ситуаций, когда блок не отработал, а исключение возникло. Например, если блока нет вообще или в подобной ситуации, когда ожидается исключение определенного вида, а вызывается другое:

try { 
    echo "В try вызвано исключение\n";
    throw new StrangeException();
} catch (SomeException $e) {
    echo "Вызвано исключение SomeException \n";
} catch (AnotherException $e) {
    echo "Вызвано исключение AnotherException \n";
} finally {
    echo "Этот блок кода выполнится всегда\n";
}

В следующем примере покажем сообщение при возникновении исключения, а затем укажем, что процесс завершен:

Результат выполнения кода:

Невозможно разделить! Процесс завершен.

В следующем примере смоделируем ситуацию, когда блока нет вообще, т.е. выведем строку «Процесс завершен», даже если исключение не было обнаружено: