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

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

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

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

class Factorial < public static int getFactorial(int num) throws FactorialException< int result=1; if(num<1) throw new FactorialException("The number is less than 1", num); for(int i=1; i<=num;i++)< result*=i; >return result; > > class FactorialException extends Exception < private int number; public int getNumber()public FactorialException(String message, int num) < super(message); number=num; >>

Здесь для определения ошибки, связанной с вычислением факториала, определен класс FactorialException , который наследуется от Exception и который содержит всю информацию о вычислении. В конструкторе FactorialException в конструктор базового класса Exception передается сообщение об ошибке: super(message) . Кроме того, отдельное поле предназначено для хранения числа, факториал которого вычисляется.

Для генерации исключения в методе вычисления факториала выбрасывается исключение с помощью оператора throw: throw new FactorialException(«Число не может быть меньше 1», num) . Кроме того, так как это исключение не обрабатывается с помощью try..catch, то мы передаем обработку вызывающему методу, используя оператор throws: public static int getFactorial(int num) throws FactorialException

Теперь используем класс в методе main:

public static void main(String[] args) < try< int result = Factorial.getFactorial(6); System.out.println(result); >catch(FactorialException ex) < System.out.println(ex.getMessage()); System.out.println(ex.getNumber()); >>

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

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

То есть, при объявлении класса MyExceptionClass наподобие

class MyExceptionClass extends Exception

экземпляр этого класса сможет использовать все методы класса Throwable . В нижеследующем коде продемонстрировано использование метода getMessage() из класса Throwable .

public class TrainException < public static void main(String[] args) < MyExceptionClass mc = new MyExceptionClass(); String str = mc.getMessage(); System.out.println("str color: #0000ff;">main()
 
str = null
Итак, в собственных реализованных подклассах, которые унаследованы от класса Exception , не обязательно реализовывать собственные методы. Часто бывает достаточно методов базового класса Throwable .
2. Пример создания класса Triangle . Вычисление площади треугольника с использованием собственного класса исключения TriangleException
В примере демонстрируется создание собственного класса TriangleException для обработки исключения «неправильно заданы стороны треугольника».
Объявляется два класса:

Triangle – реализует треугольник по его сторонам a , b , c ;
TriangleException – реализует перехват исключительной ситуации «неправильно заданы стороны треугольника».

Текст программы следующий:
import java.util.Scanner; // Создание собственного класса исключения TriangleException // Создание собственного класса Triangle, реализующего треугольник по его сторонам class TriangleException extends Exception < // переопределить метод toString(), описывающий исключение public String toString() < return "Error. Bad sides of triangle."; > > // объявить класс треугольник class Triangle < // стороны треугольника private double a,b,c; // конструктор по умолчанию public Triangle() < // равносторонний треугольник с длиной стороны 1 a = b = c = 1; > // параметризированный конструктор public Triangle(double _a, double _b, double _c) < // использование класса исключения TriangleException try < // можно ли из сторон _a, _b, _c создать треугольник if (((_a+_b)<_c)||((_a+_c)<_b)||((_b+_c)<_a)) throw new TriangleException(); > catch(TriangleException e) < System.out.println("Exception: "+e.toString()); return; > // если стороны треугольника введены корректно, // записать их во внутренние переменные класса a = _a; b = _b; c = _c; > // метод возвращающий площадь треугольника public double getArea() < // если стороны треугольника имеют корректные размеры, // то проверку на корень из отрицательного числа делать не нужно double p, s; p = (a+b+c)/2; // полупериметр s = Math.sqrt(p*(p-a)*(p-b)*(p-c)); // формула Герона return s; > > public class Train04 < // функция main() тестирует работу классов Triangle и TriangleException public static void main(String[] args) < double a, b, c; Scanner in = new Scanner(System.in); // ввод a, b, c System.out.print("a color: #0000ff;">a = in.nextDouble(); System.out.print("b color: #0000ff;">b = in.nextDouble(); System.out.print("c color: #0000ff;">c = in.nextDouble(); // вычисление площади Triangle tr = new Triangle(a,b,c); double area = tr.getArea(); System.out.println("area color: #0000ff;">TriangleException унаследован от класса Exception, который в свою очередь, унаследован от класса Throwable. Таким образом, в классе TriangleException есть доступными методы класса Throwable, в том числе метод toString(), описывающий исключение. Класс TriangleException переопределяет метод toString() класса Throwable. Это делается с целью большей конкретизации описания самого исключения.
 
В функции main() для того чтобы ввести данные, используется класс Scanner из пакета java.util. Поэтому вначале программы вводится команда
 
import java.util.Scanner;
Результат работы программы в случае, если ввести неправильные данные
a = 3 b = 1 c = 1 Exception: Error. Bad sides of triangle. area = 0.0
Результат работы программы в случае, если ввести корректные данные
a = 2 b = 2 c = 2 area = 1.7320508075688772
Собственные исключения в 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 для эффективной обработки ошибок и улучшения структуры кода!
Алексей Кодов

Автор статьи

10 июля 2023 в 17:48
Исключения в Java являются способом обработки ошибок и других нештатных ситуаций в программе. В Java есть много встроенных классов исключений, но иногда возникает необходимость создать свое собственное исключение. В этой статье мы рассмотрим, как создать и использовать кастомные исключения в Java.
Создание кастомного исключения
Для создания кастомного исключения, необходимо создать новый класс, который наследуется от одного из базовых классов исключений: Exception или RuntimeException . Например, создадим кастомное исключение InvalidAgeException , которое будет проверять возраст пользователя:
public class InvalidAgeException extends Exception < public InvalidAgeException(String message) < super(message); >>
Здесь мы создаем новый класс InvalidAgeException и наследуем его от Exception . Далее передаем сообщение об ошибке в конструктор родительского класса с помощью super(message) .
Использование кастомного исключения
Теперь, когда у нас есть кастомное исключение, давайте посмотрим, как его использовать. Например, у нас есть метод checkAge , который проверяет возраст пользователя:
public class AgeValidator < public void checkAge(int age) throws InvalidAgeException < if (age < 18) < throw new InvalidAgeException("Возраст должен быть не меньше 18 лет"); >> >
В данном случае, если возраст пользователя меньше 18 лет, мы выбрасываем наше кастомное исключение InvalidAgeException с сообщением об ошибке. Обратите внимание, что метод checkAge должен указывать в своем объявлении, что он выбрасывает исключение InvalidAgeException , используя ключевое слово throws .
Теперь вызовем метод checkAge и обработаем возможное исключение:
public class Main < public static void main(String[] args) < AgeValidator ageValidator = new AgeValidator(); try < ageValidator.checkAge(15); >catch (InvalidAgeException e) < System.out.println("Ошибка: " + e.getMessage()); >> >
Если возраст пользователя меньше 18 лет, программа выведет сообщение об ошибке:
Ошибка: Возраст должен быть не меньше 18 лет 
Java-разработчик: новая работа через 11 месяцев

Получится, даже если у вас нет опыта в IT

�� Теперь вы знаете, как создавать и использовать кастомные исключения в Java. Это может быть полезно в случаях, когда встроенных исключений недостаточно для обработки определенных ситуаций в вашей программе. Не забывайте структурировать код и обрабатывать исключения, чтобы ваша программа была устойчива к ошибкам и легко читаема. Удачи вам в изучении Java!
Читать:
Как выровнять списки по центру в css