Как добавить приложение в исключения java

Обновлено: 06.01.2025

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

Что такое Обработка исключений?

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

Зачем использовать обработку исключений?

Если мы не справимся с такими условиями, все приложение окажется в руинах, а весь остальной код устареет. Поэтому мы должны уметь писать код, который может адаптироваться к таким ситуациям.

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

В конце концов, исключения-это просто объекты Java, которые расширяют интерфейс Throwable :

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

Проверенные Исключения
Непроверенные Исключения/Исключения во Время Выполнения
Ошибки

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

Проверенные исключения-это исключения, которые мы обычно можем предвидеть и планировать заранее в нашем приложении. Это также исключения, которые компилятор Java требует, чтобы мы либо обрабатывали, либо объявляли при написании кода.

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

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

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

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

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

Ошибки

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

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

бросок и броски

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

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

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

попробуйте-поймайте блоки

Этот код пытается прочитать содержимое файла, и если файл не найден, исключение FileNotFoundException | поймано и повторно обработано . Подробнее на эту тему позже.

Запуск этого фрагмента кода без допустимого URL-адреса приведет к появлению исключения:

Запуск этого фрагмента кода без действительного URL-адреса приведет к:

наконец, Блоки

Вводя новый тип блока, блок наконец выполняется независимо от того, что происходит в блоке try. Даже если он внезапно завершится созданием исключения, блок finally будет выполнен.

Это часто использовалось для закрытия ресурсов, открытых в блоке try , поскольку возникающее исключение пропускало бы код, закрывающий их:

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

заявление о попытке использования ресурсов

Ранее сложный и подробный блок может быть заменен:

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

Кроме того, вы можете включить в этот блок несколько ресурсов, один за другим:

Таким образом, вам не нужно беспокоиться о закрытии ресурсов самостоятельно, так как блок try-with-resources гарантирует, что ресурсы будут закрыты в конце инструкции.

Несколько блоков захвата

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

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

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

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

Таким образом, мы можем обрабатывать более конкретное исключение иным способом, чем более общее.

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

Блоки захвата соединения

Чтобы уменьшить шаблонный код, в Java 7 также были введены блоки union catch/|. Они позволяют нам одинаково обрабатывать несколько исключений и обрабатывать их исключения в одном блоке:

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

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

Создание проверенного исключения

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

Git Essentials

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

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

Определить подобное исключение так же просто, как написать следующее:

Создание непроверенного исключения

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

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

Бросание

Создание исключения упоминалось ранее, поэтому вот краткий раздел для уточнения:

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

Обертывание

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

Бросание бросаемого или _Exception*?

Эти классы верхнего уровня могут быть пойманы и переосмыслены, но как это сделать, может варьироваться:

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

Однако, если мы создадим проверенное исключение в методе:

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

Наследование исключений

Подклассы, наследующие метод, могут создавать только меньшее количество проверенных исключений, чем их суперкласс:

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

Лучшие и худшие методы обработки исключений

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

Лучшие Методы Обработки Исключений

Избегайте Исключительных Условий

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

Вызов этого метода с допустимым индексом приведет к:

Но вызов этого метода с индексом, который выходит за рамки, приведет к:

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

Используйте попытку с ресурсами

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

Закройте ресурсы в try-catch-наконец-то

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

Наихудшие Методы Обработки Исключений

Глотание Исключений

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

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

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

Еще одна очень распространенная практика-просто распечатать трассировку стека исключения:

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

Вернитесь в последний блок

Если выполнение блока try завершается внезапно по какой-либо другой причине R, то наконец блок выполняется, и тогда есть выбор.

Итак, в терминологии документации, если блок наконец завершается нормально, то оператор try завершается внезапно по причине R.

Если блок finally завершается внезапно по причинам, то оператор try завершается внезапно по причинам (и причина R отбрасывается).

По сути, при резком возврате из блока finally JVM удалит исключение из блока try , и все ценные данные из него будут потеряны:

В этом случае, даже если блок try создает новый Исключение IOException , мы используем return в блоке finally , резко завершая его. Это приводит к внезапному завершению блока try из-за оператора return, а не из-за исключения IOException , что, по сути, приводит к удалению исключения в процессе.

Бросаю в последний блок

Очень похоже на предыдущий пример, использование throw в наконец блоке приведет к удалению исключения из try-catch блока:

В этом примере исключение MyException , созданное внутри блока finally , затмит исключение, созданное блоком catch , и вся ценная информация будет удалена.

Имитация оператора goto

Критическое мышление и творческие способы поиска решения проблемы-хорошая черта, но некоторые решения, какими бы творческими они ни были, неэффективны и избыточны.

Java не имеет оператора goto , как некоторые другие языки, а скорее использует метки для перехода по коду:

И все же некоторые люди используют исключения для их имитации:

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

Лесозаготовки и метания

При попытке отладить фрагмент кода и выяснить, что происходит, не регистрируйте и не создавайте исключение:

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

Почему бы нам просто не перехватить исключение или Выбрасываемое, если оно улавливает все подклассы?

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

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

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

Вывод

В этой статье мы рассмотрели исключения и обработку исключений с нуля. После этого мы рассмотрели лучшие и худшие методы обработки исключений в Java.

Надеюсь, вы нашли этот блог информативным и образовательным, счастливого кодирования!

Тоесть доступ к серверу по VNC, это фактически работа с сервером к которому подключены клавиатура и монитор.

В этой статье мы опишем возникновение ошибки при подключении к серверу по VNC и решение данной проблемы в ОС Windows.

Кликаем на кнопку "Continue"

В открывшемся окошке кликаем по кнопке "ОК"

2. Соответственно нам необходимо добавить наш апплет в список исключений безопасности Java. Для этого мы переходим в меню "Пуск" - "Все программы"

3. Далее переходим в пункт меню Java

4. Переходим в подпункт Configure Java

5. Нам откроется окно конфигурирования настроек Java.

6. Нам необходимо перейти в вкладку "Security"

7. Кликаем по кнопке "Edit Site List. " на рисунке обведена красной рамкой.

8. Нам откроется окно для добавления исключений, где мы кликаем по кнопке "Add"

9. Появится в списке строчка с пояснением, что необходимо вносить. Обведено красной рамкой.

10. Мы вносим туда ссылку https://serveradmin.freehost.com.ua/ и щёлкаем второй раз кнопку "Add"

11. Тут мы увидим предупреждение о том, что мы добавляем в исключения апплет по небезопасному протоколу http, кликаем по кнопке "Continue"

13. В списке мы видим два адреса с https:// и https:// . Вы наверное обратили внимание на разницу в адресах, в адресе с https:// отсутствует в конце слеш, это не критично. Кликаем по кнопке "ОК"

14. Видим снова окно Java с вкладками. Удостовериваемся, что ввели нужные ссылки красная рамка и далее кликаем "Ок"

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

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

Что и как происходит, когда появляется ошибка

После создания исключения, Java Runtime Environment пытается найти обработчик исключения.

Если соответствующий обработчик исключений будет найден, то объект-исключение передаётся обработчику.

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

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

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

Давайте посмотрим простую программу обработки исключений в Java.

// в методе main() пробрасывается сразу несколько исключений public static void main ( String [ ] args ) throws FileNotFoundException , IOException < // в блоке try-catch перехватываются сразу несколько исключений вызовом дополнительного catch(. ) System . out . println ( "Необязательный блок, но раз уже написан, то выполнятся будет не зависимо от того было исключение или нет" ) ; // тестовый метод создания, обработки и пробрасывания исключения public static void testException ( int i ) throws FileNotFoundException , IOException < FileNotFoundException myException = new FileNotFoundException ( "число меньше 0: " + i ) ; throw new IOException ( "Число должно быть в пределах от 0 до 10" ) ;

А в консоле эта программа напишет такое:

java . io . FileNotFoundException : число меньше 0 : - 5 at ua . com . prologistic . ExceptionHandling . testException ( ExceptionHandling . java : 24 ) at ua . com . prologistic . ExceptionHandling . main ( ExceptionHandling . java : 10 ) Необязательный блок , но раз уже написан , то выполнятся будет не зависимо от того было исключение или нет Exception in thread "main" java . io . IOException : Число должно быть в пределах от 0 до 10 at ua . com . prologistic . ExceptionHandling . testException ( ExceptionHandling . java : 27 ) at ua . com . prologistic . ExceptionHandling . main ( ExceptionHandling . java : 19 )

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

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

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

На рисунке 1 представлена иерархия исключений в Java:

Полезные методы в обработке исключений

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

Полезные методы класса Throwable :

Автоматическое управление ресурсами и улучшения блока перехвата ошибок в Java 7

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

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

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

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

1. Освободите ресурсы в блоке finally или используйте инструкцию "Try-With-Resource"

Довольно часто вы используете ресурс в своем блоке try, например InputStream, который вам нужно закрыть позже. Распространенной ошибкой в таких ситуациях является закрытие ресурса в конце блока try.

Проблема в том, что этот подход работает отлично до тех пор, пока не генерируется исключение. Все операторы в блоке try будут выполнены, и ресурс будет закрыт.

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

Поэтому вам следует поместить весь код очистки в блок finally или использовать оператор try-with-resource.

Используйте блок Finally

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

Оператор Java 7 "Try-With-Resource"

Другой вариант - это оператор try-with-resource, который я объяснил более подробно во введении в обработку исключений Java.

Вы можете использовать его, если ваш ресурс реализует интерфейс AutoCloseable. Это то, что делает большинство стандартных ресурсов Java. Когда вы открываете ресурс в предложении try, он автоматически закрывается после выполнения блока try или обработки исключения.

2. Конкретные исключения предпочтительнее

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

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

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

3. Документируйте определенные вами исключения

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

Итак, не забудьте добавить объявление @throws в свой Javadoc и описать ситуации, которые могут вызвать исключение.

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

Не поймите меня неправильно; вы не должны писать абзац текста. Но вам следует объяснить причину исключения в 1-2 коротких предложениях. Это помогает вашей группе эксплуатации понять серьезность проблемы, а также упрощает анализ любых инцидентов, связанных с обслуживанием.

Если вы выберете конкретное исключение, его имя класса, скорее всего, уже будет описывать тип ошибки. Таким образом, вам не нужно предоставлять много дополнительной информации. Хорошим примером этого является NumberFormatException. Оно вызывается конструктором класса java.lang.Long, когда вы предоставляете String в неправильном формате.

5. Сначала перехватите наиболее конкретное исключение

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

Проблема в том, что выполняется только первый блок catch, соответствующий исключению. Итак, если вы сначала поймаете IllegalArgumentException, вы никогда не достигнете блока catch, который должен обрабатывать более конкретное NumberFormatException, потому что это подкласс IllegalArgumentException.

Всегда сначала перехватывайте наиболее конкретный класс исключения и добавляйте менее конкретные блоки перехвата в конец вашего списка.

Пример такого оператора try-catch представлен в следующем фрагменте кода. Первый блок catch обрабатывает все NumberFormatException, а второй - все IllegalArgumentException, которые не являются NumberFormatException.

6. Не перехватывайте Throwable

Throwable - это суперкласс всех исключений и ошибок. Вы можете использовать его в предложении catch, но никогда не должны этого делать!

Если вы используете Throwable в предложении catch, он не только перехватит все исключения; он также перехватит все ошибки. JVM выдает ошибки, чтобы указать на серьезные проблемы, которые не предназначены для обработки приложением. Типичными примерами этого являются OutOfMemoryError или StackOverflowError. И то, и другое вызвано ситуациями, которые находятся вне контроля приложения и не могут быть обработаны.

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

7. Не игнорируйте исключения

Вы когда-нибудь анализировали отчет об ошибке, в котором выполнялась только первая часть вашего сценария использования?

Часто это вызвано игнорируемым исключением. Разработчик, вероятно, был уверен, что оно никогда не будет вызвано, и добавил блок catch, который не обрабатывает и не регистрирует его. И когда вы найдете этот блок, вы, скорее всего, даже найдете один из известных комментариев «Этого никогда не будет».

Что ж, возможно, вы анализируете проблему, в которой произошло невозможное.

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

8. Не пишите в лог сгенерированные исключения

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

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

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

9. Оберните исключение, не обрабатывая его

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

Резюме

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

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

Читайте также: