Обработка ошибок и исключения — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Как обрабатывать?)
м (rollbackEdits.php mass rollback)
 
(не показано 116 промежуточных версий 5 участников)
Строка 1: Строка 1:
{{Определение
+
==Методы обработки ошибок==
|definition=
+
'''1.''' Не обрабатывать.
Исключениями или исключительными ситуациями (состояниями) называются ошибки, возникшие в программе во время её работы.
 
}}
 
== Введение ==
 
В языке <tex>Java</tex> исключения <tex>(Exceptions)</tex> и ошибки <tex>(Errors)</tex> являются объектами. Когда метод вызывает (бросает - throws) исключительную ситуацию, он на самом деле работает с объектом. Но такое происходит не с любыми объектами, а только с теми, которые наследуются от <tex>Throwable.</tex>
 
  
[[Файл:exceptions-throwable.gif]]
+
'''2.''' Коды возврата. Основная идея {{---}} в случае ошибки возвращать специальное значение, которое не может быть корректным. Например, если в методе есть операция деления, то придется проверять делитель на равенство нулю. Также проверим корректность аргументов <code>a</code> и <code>b</code>:
  
<tex>RuntimeException</tex>, <tex>Error</tex> и их наследников еще называют <tex>unchecked</tex> <tex>exception</tex>, а всех остальных наследников класса <tex>Exception -</tex> <tex>checked</tex> <tex> exception.</tex> <tex> Checked</tex> <tex> Exception</tex> обязывает пользователя обработать ее (использую конструкцию <tex> try-catch </tex>.) или же отдать на откуп обрамляющим методам, в таком случае к декларации метода, который бросает проверяемое <tex>(checked)</tex> исключение, дописывают конструкцию <tex>throws</tex>, например
+
Double f(Double a, Double b) {
  public Date parse(String source) throws ParseException { ... }
+
    <font color=navy>'''if'''</font> ((a == <font color=navy>'''null'''</font>) || (b == <font color=navy>'''null'''</font>)) {
 +
        <font color=navy>'''return null'''</font>;
 +
    }
 +
    <font color=gray>//...</font>
 +
    <font color=navy>'''if'''</font> (Math.''abs''(b) < <font color=purple>'''EPS'''</font>) {
 +
        <font color=navy>'''return null'''</font>;   
 +
    } <font color=navy>'''else'''</font> {
 +
        <font color=navy>'''return'''</font> a / b;
 +
    }
 +
  }
  
== Так когда же нужно бросать ошибки? ==
+
При вызове метода необходимо проверить возвращаемое значение:
На этот вопрос можно ответить просто: если в методе возможна ситуация, которую метод не в состоянии обработать самостоятельно, он должен “бросать” ошибку. Но ни в коем случае нельзя использовать исключительные ситуации для управления ходом выполнения программы.
+
 
Чаще всего <tex>Exceptions</tex> бросаются при нарушении [[Программирование по контракту|контракта]] метода.
+
Double d = f(a, b);
Нарушение контракта со стороны создателя метода - это, например, что-нибудь на подобии <tex>MethodNotImplementedYetException</tex>.
+
<font color=navy>'''if'''</font> (d != <font color=navy>'''null'''</font>) {
Пользователь метода может нарушить контракт, например, таким способом: на вход <tex>Integer.parseInt(String)</tex> подать строку с буквами и по заслугам получить <tex>NumberFormatException</tex>
+
    <font color=gray>//...</font>
 +
} <font color=navy>'''else'''</font> {
 +
    <font color=gray>//...</font>
 +
}
  
== А что собственно бросать? ==
+
Минусом такого подхода является необходимость проверки возвращаемого значения каждый раз при вызове метода. Кроме того, не всегда возможно определить тип ошибки.
Выбор не то чтобы сильно велик, но и не однозначен: <tex>checked,</tex>  <tex>unchecked</tex> <tex>(runtime)</tex>, <tex>unchecked</tex> <tex>(error).</tex>
 
В подавляющем большинстве случаев <tex>Error</tex> вам не понадобится. Это в основном критические ошибки (например, <tex>StackOverflowError</tex>), с которыми пусть работает JVM.
 
<tex>Checked</tex> <tex>Exceptions</tex>, как было написано выше, заставляет программиста-пользователя написать код для ее обработки или же описать метод как “вызывающий исключительную ситуацию”.
 
С <tex>unchecked</tex> <tex> exception</tex> можно поступить по-разному. В случае с такими ошибками, пользователь сам решает, будет он обрабатывать эту ошибку, или же нет (компилятор не заставляет это делать).
 
Можно написать следующее простое правило: если некоторый набор входящих в метод данных может привести к нарушению контракта, и вы считаете, что программисту-пользователю важно разобраться с этим (и что он сможет это сделать), описывайте метод с конструкцией <tex>throws</tex>, иначе бросайте <tex>unchecked</tex> <tex>exception.</tex>
 
  
== Как обрабатывать? ==
+
'''3.'''Использовать флаг ошибки: при возникновении ошибки устанавливать флаг в соответствующее значение:
Обрабатывать ошибку лучше там, где она возникла. Если в данном фрагменте кода нет возможности принять решение, что делать с исключением, его нужно бросать дальше, пока не найдется нужный обработчик, либо поток выполнения программы не вылетит совсем.
+
 +
<font color=navy>'''boolean'''</font> <font color=purple>'''error'''</font>;
 +
 +
Double f(Double a, Double b) {
 +
    <font color=navy>'''if'''</font> ((a == <font color=navy>'''null'''</font>) || (b == <font color=navy>'''null'''</font>)) {
 +
        <font color=purple>'''error'''</font> = <font color=navy>'''true'''</font>;
 +
        <font color=navy>'''return null'''</font>;
 +
    }
 +
    <font color=gray>//...</font>
 +
    <font color=navy>'''if'''</font> (Math.''abs''(b) < <font color=purple>'''EPS'''</font>) {
 +
        <font color=purple>'''error'''</font> = <font color=navy>'''true'''</font>;
 +
        <font color=navy>'''return'''</font> b;   
 +
    } <font color=navy>'''else'''</font> {
 +
        <font color=navy>'''return'''</font> a / b;
 +
    }
 +
}
  
  class intException extends Exception {
+
  <font color=purple>'''error'''</font> = <font color=navy>'''false'''</font>;
  intException(String message){
+
Double d = f(a, b);
      super(message);
+
<font color=navy>'''if'''</font> (<font color=purple>'''error'''</font>) {
  }
+
    <font color=gray>//...</font>
 +
} <font color=navy>'''else'''</font> {
 +
    <font color=gray>//...</font>
 
  }  
 
  }  
   class Number {
+
Минусы такого подхода аналогичны минусам использования кодов возврата.
     int b;
+
 
     int division (int a) throws intExceprion{  
+
'''4.'''Можно вызвать метод обработки ошибки и возвращать то, что вернет этот метод.
         if (a == 0) throw new intException("Division by zero")
+
Double f(Double a, Double b) {
            else return this.b / a;
+
      <font color=navy>'''if'''</font> ((a == <font color=navy>'''null'''</font>) || (b == <font color=navy>'''null'''</font>)) {
 +
          <font color=navy>'''return'''</font> nullPointer();
 +
      }
 +
      <font color=gray>//...</font>
 +
      <font color=navy>'''if'''</font> (Math.''abs''(b) < <font color=purple>'''EPS'''</font>) {
 +
          <font color=navy>'''return'''</font> divisionByZero();   
 +
      } <font color=navy>'''else'''</font> {
 +
          <font color=navy>'''return'''</font> a / b;
 +
      }
 +
   }
 +
 
 +
Но в таком случае не всегда возможно проверить корректность результата вызова основного метода.
 +
 
 +
'''5.'''В случае ошибки просто закрыть программу.
 +
<font color=navy>'''if'''</font> (Math.''abs''(b) < <font color=purple>'''EPS'''</font>) {
 +
     System.''exit''(<font color=navy>0</font>);
 +
    <font color=navy>'''return this'''</font>;   
 +
}
 +
Это приведет к потере данных, также невозможно понять, в каком месте возникла ошибка.
 +
 
 +
==Исключения==
 +
В Java возможна обработка ошибок с помощью исключений:
 +
 
 +
Double f(Double a, Double b) {
 +
     <font color=navy>'''if'''</font> ((a == <font color=navy>'''null'''</font>) || (b == <font color=navy>'''null'''</font>)) {
 +
         <font color=navy>'''throw new'''</font> IllegalArgumentException(<font color=green>"arguments of f() are null"</font>);
 +
    }
 +
    <font color=grey>//...</font>
 +
    <font color=navy>'''return'''</font> a / b;
 +
}
 +
Проверять <code>b</code> на равенство нулю уже нет необходимости, так как при делении на ноль метод бросит [[Обработка_ошибок_и_исключения#RuntimeException|непроверяемое исключение]] <code>ArithmeticException</code>.
 +
 
 +
Исключения позволяют:
 +
 
 +
*разделить обработку ошибок и сам алгоритм;
 +
*не загромождать код проверками возвращаемых значений;
 +
*обрабатывать ошибки на верхних уровнях, если на текущем уровне не хватает данных для обработки. Например, при написании универсального метода чтения из файла невозможно заранее предусмотреть реакцию на ошибку, так как эта реакция зависит от использующей метод программы;
 +
*классифицировать типы ошибок, обрабатывать похожие исключения одинаково, сопоставлять специфичным исключениям определенные обработчики.
 +
 
 +
Каждый раз, когда при выполнении программы происходит ошибка, создается объект-исключение, содержащий информацию об ошибке, включая её тип и состояние программы на момент возникновения ошибки.
 +
После создания исключения среда выполнения пытается найти в стеке вызовов метод, который содержит код, обрабатывающий это исключение. Поиск начинается с метода, в котором произошла ошибка, и проходит через стек в обратном порядке вызова методов. Если не было найдено ни одного подходящего обработчика, выполнение программы завершается.
 +
 
 +
Таким образом, механизм обработки исключений содержит следующие операции:
 +
#Создание объекта-исключения.
 +
#Заполнение stack trace'а этого исключения.
 +
#Stack unwinding (раскрутка стека) в поисках нужного обработчика.
 +
 
 +
==Классификация исключений==
 +
Класс Java <code>Throwable</code> описывает все, что может быть брошено как исключение. Наследеники <code>Throwable</code> - <code>Exception</code> и <code>Error</code> - основные типы исключений. Также <code>RuntimeException</code>, унаследованный от <code>Exception</code>, является существенным классом.
 +
[[Файл:Exceptions.png|400px|thumb|right|Иерархия стандартных исключений]]
 +
===Проверяемые исключения===
 +
Наследники класса <code>Exception</code> (кроме наслеников <code>RuntimeException</code>) являются проверяемыми исключениями(''checked exception''). Как правило, это ошибки, возникшие по вине внешних обстоятельств или пользователя приложения – неправильно указали имя файла, например. Эти исключения должны обрабатываться в ходе работы программы, поэтому компилятор проверяет наличие обработчика или явного описания тех типов исключений, которые могут быть сгенерированы некоторым методом.
 +
 
 +
Все исключения, кроме классов <code>Error</code> и <code>RuntimeException</code> и их наследников, являются проверяемыми.
 +
 
 +
===Error===
 +
Класс <code>Error</code> и его подклассы предназначены для системных ошибок. Свои собственные классы-наследники для <code>Error</code> писать (за очень редкими исключениями) не нужно. Как правило, это действительно фатальные ошибки, пытаться обработать которые довольно бессмысленно (например <code>OutOfMemoryError</code>).
 +
 
 +
===RuntimeException===
 +
Эти исключения обычно возникают в результате ошибок программирования, такие как ошибки разработчика или неверное использование интерфейса приложения. Например, в случае выхода за границы массива метод бросит <code>OutOfBoundsException</code>. Такие ошибки могут быть в любом месте программы, поэтому компилятор не требует указывать runtime исключения в объявлении метода. Теоретически приложение может поймать это исключение, но разумнее исправить ошибку.
 +
 
 +
==Обработка исключений==
 +
Чтобы сгенерировать исключение используется ключевое слово <code>throw</code>. Как и любой объект в Java, исключения создаются с помощью <code>new</code>.
 +
 
 +
<font color=navy>'''if'''</font> (t == <font color=navy>'''null'''</font>) {
 +
    <font color=navy>'''throw new'''</font> NullPointerException(<font color=green>"t = null"</font>);
 +
}
 +
 
 +
Есть два стандартных конструктора для всех исключений: первый - конструктор по умолчанию, второй принимает строковый аргумент, поэтому можно поместить подходящую информацию в исключение.
 +
 
 +
Возможна ситуация, когда одно исключение становится причиной другого. Для этого существует механизм exception chaining. Практически у каждого класса исключения есть конструктор, принимающий в качестве параметра <code>Throwable</code> – причину исключительной ситуации. Если же такого конструктора нет, то у <code>Throwable</code> есть метод <code>initCause(Throwable)</code>, который можно вызвать один раз, и передать ему исключение-причину.
 +
 
 +
Как и было сказано раньше, определение метода должно содержать список всех проверяемых исключений, которые метод может бросить. Также можно написать более общий класс, среди наследников которого есть эти исключения.
 +
 
 +
<font color=navy>'''void'''</font> f() <font color=navy>'''throws'''</font> InterruptedException, IOException { <font color=gray>//...</font>
 +
 
 +
===try-catch-finally===
 +
 
 +
Код, который может бросить исключения оборачивается в <code>try</code>-блок, после которого идут блоки <code>catch</code> и <code>finally</code> (Один из них может быть опущен).
 +
 
 +
<font color=navy>'''try'''</font> {
 +
    <font color=gray>// Код, который может сгенерировать исключение</font>
 +
}
 +
 
 +
Сразу после блока проверки следуют обработчики исключений, которые объявляются ключевым словом catch.
 +
 
 +
<font color=navy>'''try'''</font> {
 +
    <font color=gray>// Код, который может сгенерировать исключение</font>
 +
} <font color=navy>'''catch'''</font>(Type1 id1) {
 +
    <font color=gray>// Обработка исключения Type1</font>
 +
} <font color=navy>'''catch'''</font>(Type2 id2) {
 +
    <font color=gray>// Обработка исключения Type2</font>
 +
}
 +
 
 +
 
 +
<code>Сatch</code>-блоки обрабатывают исключения, указанные в качестве аргумента. Тип аргумента должен быть классом, унаследованного от <code>Throwable</code>, или самим <code>Throwable</code>. Блок <code>catch</code> выполняется, если тип брошенного исключения является наследником типа аргумента и если это исключение не было обработано предыдущими блоками.
 +
 
 +
Код из блока <code>finally</code> выполнится в любом случае: при нормальном выходе из <code>try</code>, после обработки исключения или при выходе по команде <code>return</code>.
 +
 
 +
'''NB:''' Если JVM выйдет во время выполнения кода из <code>try</code> или <code>catch</code>, то <code>finally</code>-блок может не выполниться. Также, например, если поток выполняющий <code>try</code> или <code>catch</code> код остановлен, то блок <code>finally</code> может не выполниться, даже если приложение продолжает работать.
 +
 
 +
Блок <code>finally</code> удобен для закрытия файлов и освобождения любых других ресурсов. Код в блоке <code>finally</code> должен быть максимально простым. Если внутри блока <code>finally</code> будет брошено какое-либо исключение или просто встретится оператор <code>return</code>, брошенное в блоке <code>try</code> исключение (если таковое было брошено) будет забыто.
 +
 
 +
<font color=navy>'''<tt>import</tt>'''</font> java.io.IOException;
 +
 +
<font color=navy>'''<tt>public class'''</tt></font> ExceptionTest {
 +
   
 +
    <font color=navy>'''<tt>public static void</tt>'''</font> main(<tt>String[]</tt> args) {
 +
        <font color=navy>'''<tt>try</tt>'''</font> {
 +
            <font color=navy>'''<tt>try</tt>'''</font> {
 +
                <font color=navy>'''<tt>throw new</tt>''' </font>Exception(<font color=green>"a"</font>);
 +
            } <font color=navy>'''<tt>finally</tt>'''</font> {
 +
                <font color=navy>'''<tt>throw new</tt>'''</font> IOException(<font color=green>"b"</font>);
 +
            }
 +
        } <font color=navy>'''<tt>catch'''</tt></font> (IOException ex) {
 +
            System.<font color=purple>'''''err'''''</font>.println(ex.getMessage());
 +
        } <font color=navy>'''<tt>catch'''</tt></font> (Exception ex) {
 +
            System.<font color=purple>'''''err'''''</font>.println(ex.getMessage());
 
         }
 
         }
 +
    }
 +
}
 +
 +
После того, как было брошено первое исключение -  <code>new Exception("a")</code> - будет выполнен блок <code>finally</code>, в котором будет брошено исключение <code>new IOException("b")</code>, именно оно будет поймано и обработано. Результатом его выполнения будет вывод в консоль <code>b</code>. Исходное исключение теряется.
 +
 +
===Обработка исключений, вызвавших завершение потока===
 +
 +
При использовании нескольких потоков бывают ситуации, когда поток завершается из-за исключения. Для того, чтобы определить с каким именно, начиная с версии Java 5 существует интерфейс <code>Thread.UncaughtExceptionHandler</code>. Его реализацию можно установить нужному потоку с помощью метода <code>setUncaughtExceptionHandler</code>. Можно также установить обработчик по умолчанию с помощью статического метода <code>Thread.setDefaultUncaughtExceptionHandler</code>.
 +
 +
Интерфейс <code>Thread.UncaughtExceptionHandler</code> имеет единственный метод <code>uncaughtException(Thread t, Throwable e)</code>, в который передается экземпляр потока, завершившегося исключением, и экземпляр самого исключения. Когда поток завершается из-за непойманного исключения, JVM запрашивает у потока <code>UncaughtExceptionHandler</code>, используя метод <code>Thread.getUncaughtExceptionHandler()</code>, и вызвает метод обработчика – <code>uncaughtException(Thread t, Throwable e)</code>. Все исключения, брошенные этим методом, игнорируются JVM.
 +
 +
===Информация об исключениях===
 +
* <code>getMessage()</code>. Этот метод возвращает строку, которая была первым параметром при создании исключения;
 +
* <code>getCause()</code> возвращает исключение, которое стало причиной текущего исключения;
 +
* <code>printStackTrace()</code> печатает stack trace, который содержит информацию, с помощью которой можно определить причину исключения и место, где оно было брошено.
 +
 +
Exception in thread "main" java.lang.IllegalStateException: A book has a null property
 +
        at com.example.myproject.Author.getBookIds(Author.java:38)
 +
        at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
 +
Caused by: java.lang.NullPointerException
 +
        at com.example.myproject.Book.getId(Book.java:22)
 +
        at com.example.myproject.Author.getBookIds(Author.java:35)
 +
 +
Все методы выводятся в обратном порядке вызовов. В примере исключение <code>IllegalStateException</code> было брошено  в методе <code>getBookIds</code>, который был вызван в <code>main</code>. "Caused by" означает, что исключение <code>NullPointerException</code> является причиной <code>IllegalStateException</code>.
 +
 +
==Разработка исключений==
 +
Чтобы определить собственное проверяемое исключение, необходимо создать наследника класса <code>java.lang.Exception</code>. Желательно, чтобы у исключения был конструкор, которому можно передать сообщение:
 +
 +
<font color=navy>'''public class'''</font> FooException <font color=navy>'''extends'''</font> Exception {
 +
    <font color=navy>'''public'''</font> FooException() {
 +
        <font color=navy>'''super'''</font>();
 +
    }
 +
    <font color=navy>'''public'''</font> FooException(String message) {
 +
        <font color=navy>'''super'''</font>(message);
 +
    }
 +
    <font color=navy>'''public'''</font> FooException(String message, Throwable cause) {
 +
        <font color=navy>'''super'''</font>(message, cause);
 +
    }
 +
    <font color=navy>'''public'''</font> FooException(Throwable cause) {
 +
        <font color=navy>'''super'''</font>(cause);
 +
    }
 +
}
 +
 +
==Исключения в Java7==
 +
* обработка нескольких типов исключений в одном <code>catch</code>-блоке:
 +
 +
<code><font color=navy>'''catch'''</font></code> (<tt>IOException</tt> | <tt>SQLException</tt> ex) {...}
 +
 +
В таких случаях параметры неявно являются <code>final</code>, поэтому нельзя присвоить им другое значение в блоке <code>catch</code>.
 +
 +
Байт-код, сгенерированный компиляцией такого <code>catch</code>-блока будет короче, чем код нескольких <code>catch</code>-блоков.
 +
 +
* <code>Try</code> с ресурсами позволяет прямо в <code>try</code>-блоке объявлять необходимые ресурсы, которые по завершению блока будут корректно закрыты (с помощью метода <code>close()</code>). Любой объект реализующий <code>java.lang.AutoCloseable</code> может быть использован как ресурс.
 +
 +
<tt><font color=navy>'''static'''</font> String</tt> readFirstLineFromFile(String path) <tt><font color=navy>'''throws'''</font> IOException</tt> {
 +
    <tt><font color=navy>'''try'''</font></tt> (<tt>BufferedReader</tt> br =
 +
                    <tt><font color=navy>'''new'''</font> BufferedReader(<font color=navy>'''new'''</font> FileReader</tt>(path))) {
 +
        <tt><font color=navy>'''return'''</font></tt> br.readLine();
 +
    }
 +
}
 +
 +
В приведенном примере в качестве ресурса использутся объект класса <code>BufferedReader</code>, который будет закрыт вне зависимосити от того, как выполнится <code>try</code>-блок.
 +
 +
Можно объявлять несколько ресурсов, разделяя их точкой с запятой:
 +
 +
<font color=navy>'''public static void'''</font> viewTable(Connection con) throws SQLException {
 +
   
 +
    String query = <font color=green>"select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES"</font>;
 +
   
 +
    <font color=navy>'''try'''</font> (Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(query)) {
 +
        <font color=gray>//Work with Statement and ResultSet</font>
 +
    } <font color=navy>'''catch'''</font> (SQLException e) {
 +
        e.printStackTrace;
 +
    }
 +
}
 +
 +
Во время закрытия ресурсов тоже может быть брошено исключение. В try-with-resources добавленна возможность хранения "подавленных" исключений, и брошенное <code>try</code>-блоком исключение имеет больший приоритет, чем исключения получившиеся во время закрытия. Получить последние можно вызовом метода <code>getSuppressed()</code> от исключения брошенного <code>try</code>-блоком.
 +
 +
* Перебрасывание исключений с улучшенной проверкой соответствия типов.
 +
 +
Компилятор Java SE 7 тщательнее анализирует перебрасываемые исключения. Рассмотрим следующий пример:
 +
 +
  <font color=navy>'''static class'''</font> FirstException <font color=navy>'''extends'''</font> Exception { }
 +
  <font color=navy>'''static class'''</font> SecondException <font color=navy>'''extends'''</font> Exception { }
 +
 
 +
  <font color=navy>'''public void'''</font> rethrowException(String exceptionName) <font color=navy>'''throws'''</font> Exception {
 +
      <font color=navy>'''try'''</font> {
 +
          <font color=navy>'''if'''</font> (<font color=green>"First"</font>.equals(exceptionName)) {
 +
              <font color=navy>'''throw new'''</font> FirstException();
 +
          } <font color=navy>'''else'''</font> {
 +
              <font color=navy>'''throw new'''</font> SecondException();
 +
          }
 +
      } <font color=navy>'''catch'''</font> (Exception ex) {
 +
          <font color=navy>'''throw'''</font> e;
 +
      }
 
   }
 
   }
try {
+
 
    int c = a.division(b);
+
В примере <code>try</code>-блок может бросить либо <code>FirstException</code>, либо <code>SecondException</code>. В версиях до Java SE 7 невозможно указать эти исключения в декларации метода, потому что <code>catch</code>-блок перебрасывает исключение <code>ex</code>, тип которого - <code>Exception</code>.
    // Безопасное использование результата.
+
 
  } catch (intException e) {
+
В Java SE 7 вы можете указать, что метод <code>rethrowException</code> бросает только <code>FirstException</code> и <code>SecondException</code>. Компилятор определит, что исключение <code>Exception ex</code> могло возникнуть только в <code>try</code>-блоке, в котором может быть брошено <code>FirstException</code> или <code>SecondException</code>. Даже если тип параметра <code>catch</code> - <code>Exception</code>, компилятор определит, что это экземпляр либо <code>FirstException</code>, либо <code>SecondException</code>:
    // Обработка ошибки
+
 
 +
  <font color=navy>'''public void'''</font> rethrowException(String exceptionName) <font color=navy>'''throws'''</font> FirstException, SecondException {
 +
      <font color=navy>'''try'''</font> {
 +
          <font color=gray>// ...</font>
 +
      } <font color=navy>'''catch'''</font> (Exception e) {
 +
          <font color=navy>'''throw'''</font> e;
 +
      }
 +
  }
 +
 
 +
Если <code>FirstException</code> и <code>SecondException</code> не являются наследниками <code>Exception</code>, то необходимо указать и <code>Exception</code> в объявлении метода.
 +
 
 +
==Примеры исключений==
 +
* любая операция может бросить <code>VirtualMachineError</code>. Как правило это происходит в результате системных сбоев.
 +
* <code>OutOfMemoryError</code>. Приложение может бросить это исключение, если, например, не хватает места в куче, или не хватает памяти для того, чтобы создать стек нового потока.
 +
* <code>IllegalArgumentException</code> используется для того, чтобы избежать передачи некорректных значений аргументов. Например:
 +
 
 +
  <tt><font color=navy>'''public void'''</font></tt> f(<tt>Object</tt> a) { 
 +
    <tt><font color=navy>'''if'''</font></tt> (a == <tt><font color=navy>'''null'''</font></tt>) { 
 +
        <tt><font color=navy>'''throw new'''</font> IllegalArgumentException</tt>(<font color=green>"a must not be null"</font>); 
 +
    }
 +
 +
*<code>IllegalStateException</code> возникает в результате некорректного состояния объекта. Например, использование объекта перед тем как он будет инициализирован.
 +
 
 +
==Гарантии безопасности==
 +
При возникновении исключительной ситуации, состояния объектов и программы могут удовлетворять некоторым условиям, которые определяются различными типами гарантий безопасности:
 +
* Отсутствие гарантий (''no exceptional safety''). Если было брошено исключение, то не гарантируется, что все ресурсы будут корректно закрыты и что объекты, методы которых бросили исключения, могут в дальнейшем использоваться. Пользователю придется пересоздавать все необходимые объекты и он не может быть уверен в том, что может переиспозовать те же самые ресурсы.
 +
* Отсутствие утечек (''no-leak guarantee''). Объект, даже если какой-нибудь его метод бросает исключение, освобождает все ресурсы или предоставляет способ сделать это.
 +
* Слабые гарантии (''weak exceptional safety''). Если объект бросил исключение, то он находится в корректном состоянии, и все инварианты сохранены. Рассмотрим пример:
 +
 
 +
<font color=navy>'''class'''</font> Interval {
 +
    <font color=gray>//invariant: left <= right</font>
 +
   
 +
    double left;
 +
    double right;
 +
    <font color=gray>//...</font>
 
  }
 
  }
Также возможно делать несколько catch
+
 
try {
+
Если будет брошено исключение в этом классе, то тогда гарантируется, что ивариант "левая граница интервала меньше правой" сохранится, но значения <code>left</code> и <code>right</code> могли измениться.
    // Действия
+
 
} catch (*Exception e) {
+
* Сильные гарантии (''strong exceptional safety''). Если при выполнении операции возникает исключение, то это не должно оказать какого-либо влияния на состояние приложения. Состояние объектов должно быть таким же как и до вызовов методов.
    // Обработка исключения
+
 
} catch (*Exception e) {
+
* Гарантия отсутствия исключений (''no throw guarantee''). Ни при каких обстоятельствах метод не должен генерировать исключения. В Java это невозможно, например, из-за того, что <code>VirtualMachineError</code> может произойти в любом месте, и это никак не зависит от кода. Кроме того, эту гарантию практически невозможно обеспечить в общем случае.
    // Обработка исключения
+
 
} finally {
+
==Источники==
    // Действия при выходе
+
*[http://www.kgeorgiy.info/courses/java-intro/lectures/exceptions.html Обработка ошибок и исключения {{---}} Сайт Георгия Корнеева]
}
+
*[http://www.lektorium.tv/lecture/13377 Лекция Георгия Корнеева {{---}} Лекториум]
Блок <tex> finally </tex> выполняется в независимости от выполнения <tex> catch </tex>
+
*[http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html The Java Tutorials. Lesson: Exceptions]
 +
*[http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B9 Обработка исключений {{---}} Википедия]
 +
*[http://docs.oracle.com/javase/7/docs/api/java/lang/Throwable.html Throwable (Java Platform SE 7 ) {{---}} Oracle Documentation]
 +
*[http://www.skipy.ru/technics/exceptions.html try/catch/finally и исключения {{---}} www.skipy.ru]
 +
 
 +
[[Категория: Язык программирования Java]]

Текущая версия на 19:21, 4 сентября 2022

Методы обработки ошибок

1. Не обрабатывать.

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

Double f(Double a, Double b) {
    if ((a == null) || (b == null)) {
        return null;
    }
    //...
    if (Math.abs(b) < EPS) {
        return null;    
    } else {
        return a / b;
    }
}

При вызове метода необходимо проверить возвращаемое значение:

Double d = f(a, b); 
if (d != null) {
    //...
} else {
    //...
}

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

3.Использовать флаг ошибки: при возникновении ошибки устанавливать флаг в соответствующее значение:

boolean error;

Double f(Double a, Double b) {
    if ((a == null) || (b == null)) {
        error = true;
        return null;
    }
    //...
    if (Math.abs(b) < EPS) {
        error = true;
        return b;    
    } else {
        return a / b;
    }
}
error = false;
Double d = f(a, b); 
if (error) {
    //...
} else {
    //...
} 

Минусы такого подхода аналогичны минусам использования кодов возврата.

4.Можно вызвать метод обработки ошибки и возвращать то, что вернет этот метод.

Double f(Double a, Double b) {
     if ((a == null) || (b == null)) {
         return nullPointer();
     }
     //...
     if (Math.abs(b) < EPS) {
         return divisionByZero();    
     } else {
         return a / b;
     }
 }

Но в таком случае не всегда возможно проверить корректность результата вызова основного метода.

5.В случае ошибки просто закрыть программу.

if (Math.abs(b) < EPS) {
    System.exit(0);
    return this;    
}

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

Исключения

В Java возможна обработка ошибок с помощью исключений:

Double f(Double a, Double b) {
    if ((a == null) || (b == null)) {
        throw new IllegalArgumentException("arguments of f() are null");
    }
    //...
    return a / b;
}

Проверять b на равенство нулю уже нет необходимости, так как при делении на ноль метод бросит непроверяемое исключение ArithmeticException.

Исключения позволяют:

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

Каждый раз, когда при выполнении программы происходит ошибка, создается объект-исключение, содержащий информацию об ошибке, включая её тип и состояние программы на момент возникновения ошибки. После создания исключения среда выполнения пытается найти в стеке вызовов метод, который содержит код, обрабатывающий это исключение. Поиск начинается с метода, в котором произошла ошибка, и проходит через стек в обратном порядке вызова методов. Если не было найдено ни одного подходящего обработчика, выполнение программы завершается.

Таким образом, механизм обработки исключений содержит следующие операции:

  1. Создание объекта-исключения.
  2. Заполнение stack trace'а этого исключения.
  3. Stack unwinding (раскрутка стека) в поисках нужного обработчика.

Классификация исключений

Класс Java Throwable описывает все, что может быть брошено как исключение. Наследеники Throwable - Exception и Error - основные типы исключений. Также RuntimeException, унаследованный от Exception, является существенным классом.

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

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

Наследники класса Exception (кроме наслеников RuntimeException) являются проверяемыми исключениями(checked exception). Как правило, это ошибки, возникшие по вине внешних обстоятельств или пользователя приложения – неправильно указали имя файла, например. Эти исключения должны обрабатываться в ходе работы программы, поэтому компилятор проверяет наличие обработчика или явного описания тех типов исключений, которые могут быть сгенерированы некоторым методом.

Все исключения, кроме классов Error и RuntimeException и их наследников, являются проверяемыми.

Error

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

RuntimeException

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

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

Чтобы сгенерировать исключение используется ключевое слово throw. Как и любой объект в Java, исключения создаются с помощью new.

if (t == null) {
    throw new NullPointerException("t = null");
}

Есть два стандартных конструктора для всех исключений: первый - конструктор по умолчанию, второй принимает строковый аргумент, поэтому можно поместить подходящую информацию в исключение.

Возможна ситуация, когда одно исключение становится причиной другого. Для этого существует механизм exception chaining. Практически у каждого класса исключения есть конструктор, принимающий в качестве параметра Throwable – причину исключительной ситуации. Если же такого конструктора нет, то у Throwable есть метод initCause(Throwable), который можно вызвать один раз, и передать ему исключение-причину.

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

void f() throws InterruptedException, IOException { //...

try-catch-finally

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

try {
    // Код, который может сгенерировать исключение
}

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

try {
    // Код, который может сгенерировать исключение
} catch(Type1 id1) {
    // Обработка исключения Type1
} catch(Type2 id2) {
    // Обработка исключения Type2
}


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

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

NB: Если JVM выйдет во время выполнения кода из try или catch, то finally-блок может не выполниться. Также, например, если поток выполняющий try или catch код остановлен, то блок finally может не выполниться, даже если приложение продолжает работать.

Блок finally удобен для закрытия файлов и освобождения любых других ресурсов. Код в блоке finally должен быть максимально простым. Если внутри блока finally будет брошено какое-либо исключение или просто встретится оператор return, брошенное в блоке try исключение (если таковое было брошено) будет забыто.

import java.io.IOException;

public class ExceptionTest {
   
    public static void main(String[] args) {
        try {
            try {
                throw new Exception("a");
            } finally {
                throw new IOException("b");
            }
        } catch (IOException ex) {
            System.err.println(ex.getMessage());
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
        }
    }
}

После того, как было брошено первое исключение - new Exception("a") - будет выполнен блок finally, в котором будет брошено исключение new IOException("b"), именно оно будет поймано и обработано. Результатом его выполнения будет вывод в консоль b. Исходное исключение теряется.

Обработка исключений, вызвавших завершение потока

При использовании нескольких потоков бывают ситуации, когда поток завершается из-за исключения. Для того, чтобы определить с каким именно, начиная с версии Java 5 существует интерфейс Thread.UncaughtExceptionHandler. Его реализацию можно установить нужному потоку с помощью метода setUncaughtExceptionHandler. Можно также установить обработчик по умолчанию с помощью статического метода Thread.setDefaultUncaughtExceptionHandler.

Интерфейс Thread.UncaughtExceptionHandler имеет единственный метод uncaughtException(Thread t, Throwable e), в который передается экземпляр потока, завершившегося исключением, и экземпляр самого исключения. Когда поток завершается из-за непойманного исключения, JVM запрашивает у потока UncaughtExceptionHandler, используя метод Thread.getUncaughtExceptionHandler(), и вызвает метод обработчика – uncaughtException(Thread t, Throwable e). Все исключения, брошенные этим методом, игнорируются JVM.

Информация об исключениях

  • getMessage(). Этот метод возвращает строку, которая была первым параметром при создании исключения;
  • getCause() возвращает исключение, которое стало причиной текущего исключения;
  • printStackTrace() печатает stack trace, который содержит информацию, с помощью которой можно определить причину исключения и место, где оно было брошено.
Exception in thread "main" java.lang.IllegalStateException: A book has a null property
        at com.example.myproject.Author.getBookIds(Author.java:38)
        at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
Caused by: java.lang.NullPointerException
        at com.example.myproject.Book.getId(Book.java:22)
        at com.example.myproject.Author.getBookIds(Author.java:35)

Все методы выводятся в обратном порядке вызовов. В примере исключение IllegalStateException было брошено в методе getBookIds, который был вызван в main. "Caused by" означает, что исключение NullPointerException является причиной IllegalStateException.

Разработка исключений

Чтобы определить собственное проверяемое исключение, необходимо создать наследника класса java.lang.Exception. Желательно, чтобы у исключения был конструкор, которому можно передать сообщение:

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);
    }
}

Исключения в Java7

  • обработка нескольких типов исключений в одном catch-блоке:
catch (IOException | SQLException ex) {...}

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

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

  • Try с ресурсами позволяет прямо в try-блоке объявлять необходимые ресурсы, которые по завершению блока будут корректно закрыты (с помощью метода close()). Любой объект реализующий java.lang.AutoCloseable может быть использован как ресурс.
static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br =
                   new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

В приведенном примере в качестве ресурса использутся объект класса BufferedReader, который будет закрыт вне зависимосити от того, как выполнится try-блок.

Можно объявлять несколько ресурсов, разделяя их точкой с запятой:

public static void viewTable(Connection con) throws SQLException {
    
    String query = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";
    
    try (Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(query)) {
        //Work with Statement and ResultSet
    } catch (SQLException e) {
        e.printStackTrace;
    }
}

Во время закрытия ресурсов тоже может быть брошено исключение. В try-with-resources добавленна возможность хранения "подавленных" исключений, и брошенное try-блоком исключение имеет больший приоритет, чем исключения получившиеся во время закрытия. Получить последние можно вызовом метода getSuppressed() от исключения брошенного try-блоком.

  • Перебрасывание исключений с улучшенной проверкой соответствия типов.

Компилятор Java SE 7 тщательнее анализирует перебрасываемые исключения. Рассмотрим следующий пример:

 static class FirstException extends Exception { }
 static class SecondException extends Exception { }
 
 public void rethrowException(String exceptionName) throws Exception {
     try {
         if ("First".equals(exceptionName)) {
             throw new FirstException();
         } else {
             throw new SecondException();
         }
     } catch (Exception ex) {
         throw e;
     }
 }

В примере try-блок может бросить либо FirstException, либо SecondException. В версиях до Java SE 7 невозможно указать эти исключения в декларации метода, потому что catch-блок перебрасывает исключение ex, тип которого - Exception.

В Java SE 7 вы можете указать, что метод rethrowException бросает только FirstException и SecondException. Компилятор определит, что исключение Exception ex могло возникнуть только в try-блоке, в котором может быть брошено FirstException или SecondException. Даже если тип параметра catch - Exception, компилятор определит, что это экземпляр либо FirstException, либо SecondException:

 public void rethrowException(String exceptionName) throws FirstException, SecondException {
     try {
         // ...
     } catch (Exception e) {
         throw e;
     }
 }

Если FirstException и SecondException не являются наследниками Exception, то необходимо указать и Exception в объявлении метода.

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

  • любая операция может бросить VirtualMachineError. Как правило это происходит в результате системных сбоев.
  • OutOfMemoryError. Приложение может бросить это исключение, если, например, не хватает места в куче, или не хватает памяти для того, чтобы создать стек нового потока.
  • IllegalArgumentException используется для того, чтобы избежать передачи некорректных значений аргументов. Например:
public void f(Object a) {  
    if (a == null) {  
        throw new IllegalArgumentException("a must not be null");  
    }  
}  
  • IllegalStateException возникает в результате некорректного состояния объекта. Например, использование объекта перед тем как он будет инициализирован.

Гарантии безопасности

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

  • Отсутствие гарантий (no exceptional safety). Если было брошено исключение, то не гарантируется, что все ресурсы будут корректно закрыты и что объекты, методы которых бросили исключения, могут в дальнейшем использоваться. Пользователю придется пересоздавать все необходимые объекты и он не может быть уверен в том, что может переиспозовать те же самые ресурсы.
  • Отсутствие утечек (no-leak guarantee). Объект, даже если какой-нибудь его метод бросает исключение, освобождает все ресурсы или предоставляет способ сделать это.
  • Слабые гарантии (weak exceptional safety). Если объект бросил исключение, то он находится в корректном состоянии, и все инварианты сохранены. Рассмотрим пример:
class Interval {
    //invariant: left <= right
    
    double left;
    double right;
    //...
}

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

  • Сильные гарантии (strong exceptional safety). Если при выполнении операции возникает исключение, то это не должно оказать какого-либо влияния на состояние приложения. Состояние объектов должно быть таким же как и до вызовов методов.
  • Гарантия отсутствия исключений (no throw guarantee). Ни при каких обстоятельствах метод не должен генерировать исключения. В Java это невозможно, например, из-за того, что VirtualMachineError может произойти в любом месте, и это никак не зависит от кода. Кроме того, эту гарантию практически невозможно обеспечить в общем случае.

Источники