Более глубокий взгляд на исключения в Java

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

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

Объяснение иерархии исключений Java

Класс Throwable находится на вершине иерархии исключений, за которой следуют подклассы Error и Exception. Error и Exception не следует путать как одно и то же, потому что между этими двумя классами есть огромная разница.

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

Примеры исключений:

IllegalArgumentException, ClassNotFoundException и NullPointerException.

Примеры ошибок:

InternalError, OutOfMemoryError и AssertionError.

Исключения бывают двух типов: проверяемые и непроверяемые исключения. Отмеченные — это исключения времени компиляции, а неотмеченные — исключения времени выполнения. Дальнейшие подклассы RuntimeException не проверяются, а другие, кроме этого, проверяются.

Давайте лучше разберемся с исключениями и ошибками Java на примерах:

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

public static void print(String myString) {

печать (моя строка);

Исключение в потоке «основной» java.lang.StackOverflowError

в StackOverflowErrorExample.print(StackOverflowErrorExample.java:6)

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

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

public void writeToFile() {

попробовать (BufferedWriter bw = new BufferedWriter(new FileWriter("myFile.txt"))) {

bw.write("Тест");

} catch (IOException ioe) {

ioe.printStackTrace();

В приведенном выше коде операторы, написанные в блоке try, вызывают исключение IOException. IOException — проверенное исключение, оно обрабатывается в самой программе, а трассировка стека исключений выводится на консоль, как показано ниже:

Исключение в потоке «основной» java.lang.NullPointerException

в IOExceptionExample.writeToFile(IOExceptionExample.java:10)

в IOExceptionExample.main(IOExceptionExample.java:17)

Непроверенные исключения не нужно обрабатывать в коде, поэтому NullPointerException здесь не обрабатывается, обрабатывается только IOException.

Читайте также: [7 лучших платформ тестирования Java для корпоративного программного обеспечения] (https://programmers.io/top-7-java-testing-frameworks-for-enterprise-software/)

Вызов исключений Java

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

Вызов исключения требует использования в коде инструкции «throw». Упоминается объект-исключение, которое нужно генерировать вместе с сообщением. Это сообщение содержит краткую информацию об исключении, таком как проблема ввода данных пользователем, любая проблема, связанная с сервером или бэкэндом, и т. д.

Вот как вы можете сгенерировать исключение:

сгенерировать новое исключение("Сообщение об исключении");

Используя ключевое слово Throws

Ключевое слово throws определяет, что метод будет генерировать исключение. После того, как исключение будет брошено, вызывающая сторона должна обработать его с помощью блока try-catch. Мы можем генерировать либо проверенные, либо непроверенные исключения.

Ключевое слово throws предоставляет информацию о типе исключения, которое может генерировать метод, но не предотвращает прерывание программы.

В приведенном ниже примере метод toString() вызывает нулевую ссылку, которая является исключением NullPointerException.

static void testMethod() выдает исключение {

Проверка строки = ноль;

test.toString();

Как обрабатывается это исключение:

Пример открытого класса {

public static void main(String[] arg) {

попробуй {

метод теста();

} поймать (Исключение e) {

e.printStackTrace();

Класс исключений

Разработчик должен знать, как создать и выдать исключение. Это помогает более эффективно использовать исключения.

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

Читайте также: Вещи, которые можно создать с помощью Java

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

Пользовательские исключения в основном предназначены для предоставления разработчику большего контроля, чтобы лучше объяснить исключение пользователю. Встроенные исключения в Java могут не предоставлять достаточно информации, поэтому разработчику необходимо добавить больше этой информации, настроив исключение. Если исключение возникает во время выполнения программы, пользователь должен знать об этом. Пользовательское исключение — это предоставление большего количества данных и четкое объяснение.

Итак, как в Java разработчики настраивают исключения? Лучший ответ — расширение файла java.lang. Класс исключения с новым классом. Этот новый класс требует, чтобы конструктор родительского класса содержал ошибку.

Чтобы лучше понять пользовательское исключение, вот пример — предположим, что есть программа, у которой есть проблема с подключением к базе данных, в этом пользовательском исключении можно использовать. Это исключение будет содержать такие сведения, как URL-адрес базы данных, имя пользователя, пароль и т. д. В то время как блок catch может иметь индивидуальную информацию с простым читаемым сообщением для пользователя о том, что программе не удалось подключиться к базе данных.

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

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

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

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

Отслеживание исключений Java

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

Для небольших приложений легко просмотреть файл журнала. Однако корпоративные приложения могут обслуживать тысячи и даже миллионы запросов в секунду. Это делает ручной анализ слишком громоздким, поскольку ошибки и их причины могут быть потеряны в шуме. Именно здесь может помочь программное обеспечение для мониторинга ошибок, которое группирует дубликаты и предоставляет сводные представления основных и самых последних ошибок Java. Они также могут собирать и систематизировать контекстные данные таким образом, чтобы это было проще и быстрее, чем просмотр журналов.

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

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

Метод try-catch — лучший способ обработки исключений. Чтобы перехватывать определенные исключения Java, за блоком try может следовать один или несколько блоков catch, каждый из которых указывает определенный тип. Если в блоке try есть исключение, оно выбрасывается в первый блок catch, если не перехвачено этим классом, оно передается дальше, пока не будет перехвачено или не пропустит все.

Блок finally

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

Обработка необработанных исключений или исключений Java во время выполнения

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

Вывод

Java — обширный язык, и чтобы стать экспертом, Java-разработчик должен знать очень много вещей. Обработка и создание исключений — это функции, которые следует интегрировать с программами, чтобы сделать программу и результирующее приложение удобными для пользователя. Приведенные выше детали и информация делают совершенно очевидным, что изучение исключений в Java важно и является совершенно новой темой для хорошего разработчика Java. Управление, отслеживание и обработка исключений могут быть сложными во многих случаях. Вы должны управлять всеми исключениями в режиме реального времени и улучшать взаимодействие с пользователем.

Также опубликовано здесь