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

To define a checked exception you create a subclass (or hierarchy of subclasses) of java.lang.Exception. For example:

public class FooException extends Exception {
  public FooException() { super(); }
  public FooException(String message) { super(message); }
  public FooException(String message, Throwable cause) { super(message, cause); }
  public FooException(Throwable cause) { super(cause); }
}

Methods that can potentially throw or propagate this exception must declare it:

public void calculate(int i) throws FooException, IOException;

… and code calling this method must either handle or propagate this exception (or both):

try {
  int i = 5;
  myObject.calculate(5);
} catch(FooException ex) {
  // Print error and terminate application.
  ex.printStackTrace();
  System.exit(1);
} catch(IOException ex) {
  // Rethrow as FooException.
  throw new FooException(ex);
}

You’ll notice in the above example that IOException is caught and rethrown as FooException. This is a common technique used to encapsulate exceptions (typically when implementing an API).

Sometimes there will be situations where you don’t want to force every method to declare your exception implementation in its throws clause. In this case you can create an unchecked exception. An unchecked exception is any exception that extends java.lang.RuntimeException (which itself is a subclass of java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Methods can throw or propagate FooRuntimeException exception without declaring it; e.g.

public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}

Unchecked exceptions are typically used to denote a programmer error, for example passing an invalid argument to a method or attempting to breach an array index bounds.

The java.lang.Throwable class is the root of all errors and exceptions that can be thrown within Java. java.lang.Exception and java.lang.Error are both subclasses of Throwable. Anything that subclasses Throwable may be thrown or caught. However, it is typically bad practice to catch or throw Error as this is used to denote errors internal to the JVM that cannot usually be «handled» by the programmer (e.g. OutOfMemoryError). Likewise you should avoid catching Throwable, which could result in you catching Errors in addition to Exceptions.

Создание своих классов исключений

Последнее обновление: 23.04.2018

Хотя имеющиеся в стандартной библиотеке классов 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(){return number;}
    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());
    }
} 

Автор оригинала: Dhananjay Singh.

Обзор

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

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

Зачем Использовать Пользовательские Исключения?

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

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

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

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

Исключение С Пользовательской Проверкой

Давайте рассмотрим сценарий, в котором мы хотим проверить электронное письмо, переданное в качестве аргумента методу.

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

Но предположим, что у нас также есть бизнес-условие, чтобы проверить, что все электронные письма в нашей системе должны быть уникальными. Теперь мы должны выполнить вторую проверку (вызов БД/сети). Мы можем, конечно, использовать то же самое Исключение IllegalArgumentException , но будет неясно, какова точная причина – не прошла ли проверка регулярного выражения по электронной почте или электронное письмо уже существует в базе данных.

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

public class EmailNotUniqueException extends Exception {

    public EmailNotUniqueException(String message) {
        super(message);
    }
}

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

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

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

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

public class RegistrationService {  
    List registeredEmails = Arrays.asList("[email protected]", "[email protected]");

    public void validateEmail(String email) throws EmailNotUniqueException {
        if (registeredEmails.contains(email)) {
            throw new EmailNotUniqueException("Email Already Registered");
        }
    }
}

Теперь давайте напишем клиента для нашего сервиса. Поскольку это проверенное исключение, мы должны придерживаться правила обработки или объявления. В следующем примере мы решили “разобраться” с этим:

public class RegistrationServiceClient {  
    public static void main(String[] args) {
        RegistrationService service = new RegistrationService();
        try {
            service.validateEmail("[email protected]");
        } catch (EmailNotUniqueException e) {
            // logging and handling the situation
        }
    }
}

Запуск этого фрагмента кода приведет к:

mynotes.custom.checked.exception.EmailNotUniqueException: Email Already Registered  
    at mynotes.custom.checked.exception.RegistrationService.validateEmail(RegistrationService.java:12)
    at mynotes.custom.checked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:9)

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

Пользовательское Непроверенное Исключение

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

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

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

public class DomainNotValidException extends RuntimeException {

    public DomainNotValidException(String message) {
        super(message);
    }
}

Git Essentials

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

Теперь позвольте использовать его в нашем сервисе:

public class RegistrationService {

    public void validateEmail(String email) {
        if (!isDomainValid(email)) {
            throw new DomainNotValidException("Invalid domain");
        }
    }

    private boolean isDomainValid(String email) {
        List validDomains = Arrays.asList("gmail.com", "yahoo.com", "outlook.com");
        if (validDomains.contains(email.substring(email.indexOf("@") + 1))) {
            return true;
        }
        return false;
    }
}

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

Теперь давайте напишем клиента для нашего сервиса. На этот раз нам не нужно использовать try-catch блок:

public class RegistrationServiceClient {

    public static void main(String[] args) {
        RegistrationService service = new RegistrationService();
        service.validateEmail("[email protected]");
    }
}

Запуск этого фрагмента кода приведет к:

Exception in thread "main" mynotes.custom.unchecked.exception.DomainNotValidException: Invalid domain  
    at mynotes.custom.unchecked.exception.RegistrationService.validateEmail(RegistrationService.java:10)
    at mynotes.custom.unchecked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:7)

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

Создание исключения, Заключенного в пользовательское исключение

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

Предположим, что ваше приложение имеет стандартный Коды ошибок класс:

public enum ErrorCodes {  
    VALIDATION_PARSE_ERROR(422);

    private int code;

    ErrorCodes(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

Давайте создадим наше пользовательское исключение:

public class InvalidCurrencyDataException extends RuntimeException {

    private Integer errorCode;

    public InvalidCurrencyDataException(String message) {
        super(message);
    }

    public InvalidCurrencyDataException(String message, Throwable cause) {
        super(message, cause);
    }

    public InvalidCurrencyDataException(String message, Throwable cause, ErrorCodes errorCode) {
        super(message, cause);
        this.errorCode = errorCode.getCode();
    }

    public Integer getErrorCode() {
        return errorCode;
    }
}

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

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

Давайте напишем наш класс обслуживания:

public class CurrencyService {  
    public String convertDollarsToEuros(String value) {
        try {
        int x = Integer.parseInt(value);
    } catch (NumberFormatException e) {
        throw new InvalidCurrencyDataException("Invalid data", e, ErrorCodes.VALIDATION_PARSE_ERROR);
        }
        return value;
    }
}

Поэтому мы поймали стандартное Исключение NumberFormatException и выбросили наше собственное Исключение Недопустимых Валютных данных . Мы передали родительское исключение нашему пользовательскому исключению, чтобы не потерять первопричину, из-за которой они произошли.

Давайте напишем тестовый клиент для этой службы:

public class CurrencyClient {  
    public static void main(String[] args) {
        CurrencyService service = new CurrencyService();
    service.convertDollarsToEuros("asd");
    }
}

Выход:

Exception in thread "main" mynotes.custom.unchecked.exception.InvalidCurrencyDataException: Invalid data  
    at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:10)
    at mynotes.custom.unchecked.exception.CurrencyClient.main(CurrencyClient.java:8)
Caused by: java.lang.NumberFormatException: For input string: "asd"  
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Integer.parseInt(Integer.java:580)
    at java.lang.Integer.parseInt(Integer.java:615)
    at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:8)
    ... 1 more

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

Рекомендации по использованию пользовательских исключений

• Придерживайтесь общего соглашения об именовании во всей экосистеме Java – Все имена пользовательских классов исключений должны заканчиваться на “Исключение”
• Избегайте создания пользовательских исключений, если стандартные исключения из самого JDK могут служить этой цели. В большинстве случаев нет необходимости определять пользовательские исключения.
• Предпочитайте исключения во время выполнения проверенным исключениям. Фреймворки, такие как Spring , заключили все проверенные исключения в исключения времени выполнения, поэтому не заставляют клиента писать стандартный код, который им не нужен или не нужен.
• Предоставьте множество перегруженных конструкторов, основанных на том, как будет создаваться пользовательское исключение. Если он используется для повторного создания существующего исключения, то обязательно предоставьте конструктор, который устанавливает причину.

Вывод

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

Код для примеров, используемых в этой статье, можно найти на Github .

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

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

Иерархия

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

Взгляните на упрощённую схему иерархии исключений java:

Как видно, блоки делятся на «два лагеря» по цветам  — проверяемые и непроверяемые java исключения. Данная классификация показывает, как их воспринимает компилятор: проверяемые – учитывает, непроверяемые – игнорирует. К первому относится Exception в полном составе, кроме RuntimeException. Все остальные классы исключений – непроверяемые компилятором.

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

Создание обработчика

Для обработки исключений java используются следующие операторы: try, catch, finally, throw, throws. Первые три — стандартная структура вашего блока. По шагам:

1. Оператор или часть кода, в которой вам надо отыскать ошибку, помещается в блок try.
2. Далее в блоке catch вы указываете, что за исключение надо ловить и как его обрабатывать.
3. В блоке finally набор обязательных действий при возникновении ошибки. Обычно это запись данных, закрытие ресурсов и пр. Блок исполняется всегда, вне зависимости от срабатывания catch.

Рассмотрим структуру на примере Джава исключения:

try {
// код, где мы хотим отследить ошибку
}
catch (тип_исключения объект_исключения) {
// код обработки
}
finally {
// что нужно выполнить после завершения блока try
}

Если вы хотите обработать несколько исключений – просто создайте ещё один блок catch.

try {
// код, где мы хотим отследить ошибку
}
catch (тип_исключения_1 объект_исключения_1) {
// код обработки
}
catch (тип_исключения_2 объект_исключения_2) {
// код обработки
}
finally {
// что нужно выполнить после завершения блока try
}

С помощью оператора throw вы можете создавать исключения:

throw экземпляр_Throwable

На практике это выглядит так:

Student stud1;
public void onClick(View view) {
  if(stud1 == null){
    throw new NullPointerException(«Студента не существует»);
  }
}

Включим оператор throw в наш стандартный пример с try-catch:

public void onClick(View view) {
  if (stud1 == null) {
    try {
      throw new NullPointerException(«Студента не существует»);
    } catch (NullPointerException e) {
      Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show();
    }
  }
}

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

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

тип имя_метода(список_параметров) throws список_исключений {
// код метода
}

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

Операторы try можно вкладывать друг в друга. При этом если вложенный обработчик не имеет своего блока catch, он осуществляет его поиск в родительском операторе. Если и там нет – блок обрабатывается системой.

Готовые и новые исключения

Далее приведём список java исключений, которые вам потребуются в работе чаще других:

• ArithmeticException — ошибки вычислений.
• NullPointerException — ссылка на пустое место.
• NegativeArraySizeException — массив отрицательной размерности.
• ArrayStoreException — присвоение элементу массива неправильного типа.
• NumberFormatException — невозможно преобразовать строку в число.
• IllegalArgumentException — неправильный аргумент при вызове метода.
• UnsupportedOperationException — указанной операции не существует.
• TypeNotPresentException — указанного типа не существует.

Все указанные типы java исключений содержатся в классе RuntimeException, а значит, их не надо указывать в блоке throws.

Естественно, система не может содержать всевозможные исключения. Некоторые придётся создавать самостоятельно. Для того, чтобы создать собственное java исключение, вам необходимо унаследовать собственный класс от Exception и переопределить требуемые методы класса Throwable. Или унаследоваться от наиболее близкого по смыслу типа. Рассмотрим на примере программы под android создание java исключения:

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