Перейти к содержимому

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

  • автор:

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

4.1. Ошибки (т.е. ситуация, когда выполнение какой-то функции должно быть прервано), например извлечение из файла ID некоторого множества. Т.е. продолжать обработку следующих множеств можно. Пример:

public void startPreparations(LinkedList dataEntityList) < for(int i=0; icatch (MyDataEntityException mdee) < MyExceptionHandler(mdee, LogLevel.ERROR); continue; >. > > private int getId(MyDataEntity dataEntity) throws MyDataEntityException < //. throw (new . ) где-то тут >

Это лишь пример.

4.2. Предупреждения. В них похожая ситуация как и в (4.1) только предупреждения обрабатываются локально (например, в функции getId()) или без прерывания цикла (continue).

В общем как-то так. Скажите, насколько это решение было благоразумным?

Отслеживать
задан 15 мар 2011 в 14:48
9,981 3 3 золотых знака 35 35 серебряных знаков 60 60 бронзовых знаков

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

В зависимости от ситуации и типа приложения.

По мне так в GUI-приложениях лучше всего сделать какой-нибудь ErrorNotificationManager, которому следует сообщать ошибку по мере отлова, а уж он пусть принимает решение, как отображать её. В момент передачи менеджеру можно и передавать аналог лог-левела, чтобы намекнуть ему о критичности ошибки в данном конкретном контексте.

Если же речь идёт о логгировании, то просто логгируйте с нужным логлевелом и получите то что надо.

UPD1

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

UPD2

Что вы, я мало кого считаю глупым 🙂

Итак, у нас имеется три вида ошибок: критические, просто ошибки и ошибки уровня warning.

О критических ошибках. В случае подобных ошибок можно заставить handler всё завершать (можно даже жёстко через System.exit). С другой стороны, можно протащить такую ошибку сквозь все уровни или сделать её от RuntimeException, чтобы не пришлось всюду протягивать её через throws. А ловить тогда прямо в корне. Если нет потоков, то на мой вкус второй вариант лучше. Если есть, то можно скомбинировать оба подхода (только без System.exit)

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

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

public void startPreparations(List dataEntityList) throws MyFatalPreparationException < for(MyDataEntity dataEntity : dataEntityList) < try < processId(getId(dataEntity)); >catch (MyDataEntityException mdee) < MyExceptionHandler(mdee, LogLevel.ERROR); >> > private void processId(MyDataEntity dataEntity) throws MyFatalPreparationException < // . >private int getId(MyDataEntity dataEntity) throws MyDataEntityException < //. throw (new . ) где-то тут >

Собственные исключения в Java: как управлять ошибками в вашем приложении

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

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

Зачем нужны собственные исключения?

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

1. Отражение специфических ситуаций: Собственные исключения могут быть созданы для отображения конкретных ошибок или ситуаций, которые могут возникнуть в приложении. Например, вы можете создать исключение InvalidInputException , чтобы указать, что получен недопустимый ввод от пользователя.

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

3. Гибкая обработка и восстановление: При использовании собственных исключений вы можете предоставить гибкую обработку ошибок, включая восстановление после ошибки или выполнение альтернативных действий. Например, вы можете перехватить исключение FileNotFoundException и попробовать открыть альтернативный файл.

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

5. Расширение стандартных исключений: Собственные исключения могут расширять стандартные исключения Java, такие как Exception или RuntimeException , чтобы добавить дополнительную информацию или функциональность при обработке ошибок. Например, вы можете создать исключение DatabaseException , которое расширяет Exception и содержит дополнительные методы для работы с базой данных.

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

Пример 1

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

public class InvalidInputException extends Exception < public InvalidInputException(String message) < super(message); >>

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

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

public class Example < public static void main(String[] args) < try < validateInput("abc"); >catch (InvalidInputException e) < System.out.println("Invalid input: " + e.getMessage()); >> public static void validateInput(String input) throws InvalidInputException < if (input == null || input.isEmpty()) < throw new InvalidInputException("Input cannot be null or empty"); >> >

В этом примере метод validateInput() проверяет, является ли входная строка пустой или равной null . Если это так, то метод выбрасывает исключение InvalidInputException с сообщением. В методе main() мы вызываем validateInput() с недопустимым вводом и перехватываем исключение с помощью блока catch , где выводим сообщение об ошибке.

Пример 2
// Создаем собственное исключение class CustomException extends Exception < public CustomException(String message) < super(message); >> // Класс, который использует собственное исключение class Example < // Метод, который может выбросить собственное исключение public static void doSomething(int value) throws CustomException < if (value < 0) < throw new CustomException("Значение должно быть больше или равно нулю"); >> public static void main(String[] args) < try < // Вызываем метод, который может выбросить исключение doSomething(-5); >catch (CustomException e) < // Обрабатываем исключение System.out.println("Ошибка: " + e.getMessage()); >> >

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

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

Пример 3
// Создаем собственное исключение class InvalidEmailException extends Exception < public InvalidEmailException(String message) < super(message); >> // Класс, который использует собственное исключение class EmailValidator < // Метод, который может выбросить собственное исключение public static void validateEmail(String email) throws InvalidEmailException < if (!email.contains("@")) < throw new InvalidEmailException("Некорректный адрес электронной почты"); >> public static void main(String[] args) < try < // Вызываем метод, который может выбросить исключение validateEmail("example.com"); >catch (InvalidEmailException e) < // Обрабатываем исключение System.out.println("Ошибка: " + e.getMessage()); >> >

В этом примере у нас есть метод validateEmail , который может выбросить собственное исключение InvalidEmailException , если переданный адрес электронной почты не содержит символа «@». В конструкторе исключения мы передаем сообщение об ошибке. В методе main мы вызываем этот метод с некорректным адресом электронной почты и перехватываем исключение с помощью блока catch . Затем мы выводим сообщение об ошибке.

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

Пример 4 (некорректное создание исключений)
// Некорректное создание собственного исключения class MyException extends Exception < public MyException() < super(); >>

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

Корректным подходом будет передача сообщения об ошибке через конструктор, как показано в предыдущем примере:

class MyException extends Exception < public MyException(String message) < super(message); >>

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

Пример 5 (некорректное использование)

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

public class MyCustomException extends Exception < // . >public class Example < public static void main(String[] args) < try < throw new MyCustomException(); >catch (MyCustomException e) < System.out.println("Caught MyCustomException"); >catch (Exception e) < System.out.println("Caught Exception"); >> >

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

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

Плюсы создания собственных исключений:

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

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

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

4. Расширение стандартных исключений: Вы можете расширять стандартные исключения Java, такие как Exception или RuntimeException , с добавлением дополнительной функциональности или информации для обработки ошибок. Это позволяет вам более точно определить тип ошибки и предоставить дополнительные методы для работы с ней.

Минусы создания собственных исключений:

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

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

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

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

Заключение

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

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

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

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

Основные типы исключений

В Java существует три основных типа исключений:

  1. Checked Exceptions (Проверяемые исключения): Эти исключения проверяются компилятором во время компиляции. Программист обязан обработать такие исключения, иначе программа не скомпилируется. Примеры: IOException , SQLException . Проверяемые исключения обычно возникают в результате внешних факторов, таких как проблемы с файлами, сетью или базой данных. Например, при попытке открыть файл, который не существует, будет выброшено исключение FileNotFoundException .
  2. Unchecked Exceptions (Непроверяемые исключения): Эти исключения не проверяются компилятором. Они возникают во время выполнения программы и обычно являются результатом ошибок программиста. Примеры: NullPointerException , ArrayIndexOutOfBoundsException . Непроверяемые исключения часто возникают из-за логических ошибок в коде, таких как попытка доступа к элементу массива по недопустимому индексу или вызов метода на объекте, который равен null.
  3. Errors (Ошибки): Эти исключения представляют собой серьезные проблемы, которые обычно не могут быть обработаны программой. Примеры: OutOfMemoryError , StackOverflowError . Ошибки обычно указывают на проблемы, связанные с ресурсами системы, такие как нехватка памяти или переполнение стека. Эти проблемы обычно не могут быть решены программным путем и требуют вмешательства пользователя или администратора системы.

Использование try-catch блоков

Основной механизм обработки исключений в Java — это использование блоков try-catch . Блок try содержит код, который может вызвать исключение, а блок catch — код, который обрабатывает это исключение.

Java. Исключения (exceptions). Исключительная ситуация. Ключевые слова try, catch, finally. Примеры

Исключения (exceptions). Исключительная ситуация. Ключевые слова try , catch , finally . Примеры

Поиск на других ресурсах:

1. Что такое исключительная ситуация?

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

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

Правильная обработка исключений есть важным элементом написания профессиональных программ на Java.

2. Понятие исключения в языке Java

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

В языке программирования Java, исключение – это специальный объект, описывающий исключительную ситуацию, которая возникла в некоторой части программного кода. Объект представляющий исключение, генерируется в момент возникновения исключительной ситуации. После возникновения критической (исключительной) ситуации исключение перехватывается и обрабатывается. Таким образом, возникает понятие генерирования исключения. Генерирование исключения – процесс создания объекта, который описывает данное исключение.

3. Какими способами могут генерироваться исключения?

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

  • автоматически. В этом случае исключения генерируются исполнительной системой Java. К таким исключениям входят ошибки, которые понимают правила языка Java или ограничения, которые накладываются системой;
  • вручную. В этом случае исключения генерируются в программном коде, который разрабатывается. Ручные исключения программируются для сообщения вызывающему коду о возможных ошибках в методах разрабатываемой программы.
4. В каких случаях вызывается стандартный обработчик исключений Java?

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

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

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

5. Какие ключевые слова используются для обработки исключений в Java?

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

  • try ;
  • catch ;
  • throw ;
  • throws ;
  • finally .
6. Какое назначение конструкции try… catch…finally ? Общая форма

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

Для отслеживания, генерирования и обработки исключений в языке программирования Java используется конструкция try…catch…finally , которая имеет следующую общую форму

try < // блок кода, в котором отслеживаются и генерируются исключения // . > catch (type_exception_1 objEx1) < // обработчик исключения типа type_exception_1 // . > catch (type_exception_2 objEx2) < // обработчик исключения типа type_exception_2 // . > . catch (type_exception_N objEx) < // обработчик исключения типа type_exception_N // . > finally < // блок кода, который должен быть обязательно выполнен // после завершения блока try // . >

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

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

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

Операторы try и catch составляют единое целое. Оператор finally может отсутствовать.

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

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

Объявляется класс DemoExceptions . С целью демонстрации в классе объявляется метод DivNumbers() . Метод возвращает число типа double , которое есть результатом деления двух целых значений переменных a и b . Эти переменные есть входными параметрами метода.

Если b = 0 то при делении a на b может возникнуть исключительная ситуация «деление на нуль» типа ArithmeticException . В программе нет кода, который явным образом перехватывает и обрабатывает эту ситуацию. Поэтому, вызывается стандартный обработчик Java.

Текст класса DemoExceptions следующий:

// класс реализующий метод, // в котором может возникнуть исключительная ситуация class DemoExceptions < // метод, в котором может возникнуть деление на 0  double DivNumbers(int a, int b) < // при делении на 0 будет вызван стандартный обработчик Java  double res; res = a/b;  return res; > >

Если в другом классе использовать метод DivNumbers() следующим образом

public class Train01 <  public static void main(String[] args) < DemoExceptions d = new DemoExceptions(); // создать экземпляр класса double res; // вызвать метод DivNumbers() res = d.DivNumbers(2, 0); // 2/0 => деление на ноль System.out.println("res color: #ff0000;">Exception in thread "main" java.lang.ArithmeticException: / by zero at DemoExceptions.DivNumbers(Train01.java:10) at Train01.main(Train01.java:82)

В сообщении указывается тип класса ArithmeticException . Это подкласс производный от класса RunTimeException . Этот подкласс описывает арифметические ошибки «деление на 0», «взятие корня из отрицательного числа» и т.п..

8. Пример перехвата и обработки исключения с помощью оператора try…catch

В примере реализован класс DemoExceptions , в котором объявляется метод с именем DivNumbers2() . Метод DivNumbers2() делит входящий параметр a на входящий параметр b . В методе DivNumbers2() продемонстрирован перехват исключения деления на ноль с помощью блока try…catch .

Текст класса DemoExceptions следующий

// класс реализующий метод, // в котором может возникнуть исключительная ситуация class DemoExceptions < // метод, в котором обработано деление на 0, // блок try..catch  double DivNumbers2(int a, int b) <  double res=0; // переменная res обязательно должна быть инициализирована  try < res = a/b; // если b=0, то генерируется исключение >  catch (ArithmeticException e) < System.out.println("Деление на 0."); >  return res; > >

Теперь, при использовании метода DivNumbers2() в другом классе

public class Train01 <  public static void main(String[] args) < DemoExceptions d = new DemoExceptions(); // создать экземпляр класса double res; // вызвать метод DivNumbers2() res = d.DivNumbers2(2, 0); // 2/0 => деление на ноль System.out.println("res color: #0000ff;">DivNumbers2() будет вызван собственный обработчик, который реализован в операторе try…catch. В блок try помещается программный код, который нужно проверить

. res = a/b; .

Если возникает исключение ( b=0 ), то управление сразу передается из блока try в блок catch . В блоке catch происходит обработка исключения с выводом соответствующего сообщения

. catch (ArithmeticException e) < System.out.println("Деление на 0."); > .
  • генерируется исключение типа ArithmeticException ;
  • происходит переход к обработке исключения (блок catch );
  • в блоке catch выводится соответствующее сообщение;
  • после блока catch выполнение программы не останавливается. В результате переменная res получает значение 0.

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

. catch (ArithmeticException e) < System.out.println(e); //System.out.println("Деление на 0."); > .

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

java.lang.ArithmeticException: / by zero res = 0.0
9. Пример перехвата и обработки исключения блоком try…catch…finally . Демонстрация работы блока операторов finally

В примере продолжено развитие двух предшествующих пунктов 7, 8. Пример демонстрирует назначение блока finally в операторе try…catch…finally .

Объявляется класс DemoExceptions . В классе продемонстрирован перехват исключительной ситуации деления на 0. Этот перехват реализован в методе DivNumbers3() класса. Для перехвата и обработки исключительной ситуации, метод DivNumbers3() использует оператор try…catch…finally .

Текст класса DemoExceptions следующий

// класс, который реализует метод, // в котором может возникнуть исключительная ситуация class DemoExceptions < // метод, в котором обработано деление на 0, // блок try..catch..finally double DivNumbers3(int a, int b) <  double res; // не обязательно инициализировать, поскольку есть блок finally  try  < res = a/b; > catch (ArithmeticException e) < System.out.println("Деление на 0."); >  finally < res = 0; // вызовется обязательно >  return res; > >

В методе DivNumbers3() объявляется переменная res , что есть результатом деления a на b . Поскольку оператор try…catch содержит блок finally , то строка

. finally < res = 0; // вызовется обязательно > .

будет вызываться всегда. И перед оператором

. return res; .

переменная res будет всегда инициализирована. Поэтому компилятор Java не требует инициализации переменной в начале кода. Как известно, чтобы возвратить значение переменной оператором return , эта переменная должна быть обязательно инициализирована. Итак, блок finally вызывается всегда.

Использование метода DivNumbers3() в другом классе может быть следующим

public class Train01 <  public static void main(String[] args) < DemoExceptions d = new DemoExceptions(); double res; res = d.DivNumbers3(2, 0); // 2/0 => деление на ноль System.out.println("res color: #333300;">⇑ 
10. Как реализовать вывод описания исключения? Пример

Если нужно вывести описание исключения e, то можно изменить вывод в обработчике catch следующим образом (см. пункт 8)

. catch (ArithmeticException e) < // перехватить ошибку деления на 0 System.out.println("Исключение: " + e); > .

В результате программа будет выводить следующий результат

Исключение: java.lang.ArithmeticException: / by zero
11. Пример перехвата нескольких исключительных ситуаций (несколько операторов catch )

Бывают случаи, когда в одном фрагменте кода может возникнуть несколько исключений. Для обработки нескольких исключительных ситуаций в блоке try…catch можно использовать несколько операторов catch . Каждый из операторов catch используется для перехвата отдельного типа исключения.

Реализация класса DivArrays следующая

// несколько операторов catch // класс, который делит поэлементно массивы class DivArrays <  double[] A1;  double[] A2; // конструктор класса DivArrays(int n1, double[] _A1, int n2, double[] _A2) < // создать массивы A1 = new double[n1]; for (int i=0; inew double[n2]; for (int i=0; i // метод, который делит поэлементно массив A1 на массив A2 // метод возвращает массив типа double  double[] Division() <  double[] A3; int n3; // установить наибольший из размеров  if (A1.length > A2.length) n3 = A1.length;  else n3 = A2.length; A3 = new double[n3]; // цикл по i, в цикле обрабатывается исключительная ситуация  for (int i=0; i try < // сгенерировать исключение, если деление на 0 if (A2[i]==0.0)  throw new ArithmeticException(); A3[i] = A1[i]/A2[i]; >  catch (ArithmeticException e) < // перехватить деление на 0 A3[i] = 0; // просто установить в A3 значение 0 > catch (ArrayIndexOutOfBoundsException e) < // перехватить выход индекса за границы массива // это случай, когда длины массивов отличаются A3[i] = -1; > >  return A3; > >

Использование класса в другом программном коде

public class Train03 < public static void main(String[] args) < double [] A1 = < 2.5, 2.0, 1.5, 0.5 >; double [] A2 = < 1.0, 0.0, 2.0 >; double [] A3; DivArrays dA = new DivArrays(4,A1,3,A2); A3 = dA.Division(); // вывести массив d for ( int i=0; iout .println( "A[" + i + "] color: #333300;">⇑

Связанные темы

  • Операторы throw , throws . Примеры
  • Классы Java для обработки исключительных ситуаций из пакета java.lang . Методы класса Throwable . Примеры
  • Класс Exception . Создание собственных классов исключений. Примеры

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *