Java исключения для чего нужны. Java: Операторы throw и throws
Последнее обновление: 30.10.2015
Нередко в процессе выполнения программы могут возникать ошибки, при том необязательно по вине разработчика. Некоторые из них трудно предусмотреть или предвидеть, а иногда и вовсе невозможно. Так, например, может неожиданно оборваться сетевое подключение при передаче файла. Подобные ситуации называются исключениями .
В языке Java предусмотрены специальные средства для обработки подобных ситуаций. Одним из таких средств является конструкция try...catch...finally . При возникновении исключения в блоке try управление переходит в блок catch, который может обработать данное исключение. Если такого блока не найдено, то пользователю отображается сообщение о необработанном исключении, а дальнейшее выполнение программы останавливается. И чтобы подобной остановки не произошло, и надо использовать блок try..catch. Например:
Int numbers = new int; numbers=45; System.out.println(numbers);
Так как у нас массив numbers может содержать только 3 элемента, то при выполнении инструкции numbers=45 консоль отобразит исключение, и выполнение программы будет завершено. Теперь попробуем обработать это исключение:
Try{ int numbers = new int; numbers=45; System.out.println(numbers); } catch(Exception ex){ ex.printStackTrace(); } System.out.println("Программа завершена");
При использовании блока try...catch вначале выполняются все инструкции между операторами try и catch. Если в блоке try вдруг возникает исключение, то обычный порядок выполнения останавливается и переходит к инструкции сatch. Поэтому когда выполнение программы дойдет до строки numbers=45; , программа остановится и перейдет к блоку catch
Выражение catch имеет следующий синтаксис: catch (тип_исключения имя_переменной) . В данном случае объявляется переменная ex , которая имеет тип Exception . Но если возникшее исключение не является исключением типа, указанного в инструкции сatch, то оно не обрабатывается, а программа просто зависает или выбрасывает сообщение об ошибке.
Но так как тип Exception является базовым классом для всех исключений, то выражение catch (Exception ex) будет обрабатывать практически все исключения. Обработка же исключения в данном случае сводится к выводу на консоль стека трассировки ошибки с помощью метода printStackTrace() , определенного в классе Exception.
После завершения выполнения блока catch программа продолжает свою работу, выполняя все остальные инструкции после блока catch.
Конструкция try..catch также может иметь блок finally . Однако этот блок необязательный, и его можно при обработке исключений опускать. Блок finally выполняется в любом случае, возникло ли исключение в блоке try или нет:
Try{ int numbers = new int; numbers=45; System.out.println(numbers); } catch(Exception ex){ ex.printStackTrace(); } finally{ System.out.println("Блок finally"); } System.out.println("Программа завершена");
Обработка нескольких исключений
В Java имеется множество различных типов исключений, и мы можем разграничить их обработку, включив дополнительные блоки catch:
Int numbers = new int; try{ numbers=45; numbers=Integer.parseInt("gfd"); } catch(ArrayIndexOutOfBoundsException ex){ System.out.println("Выход за пределы массива"); } catch(NumberFormatException ex){ System.out.println("Ошибка преобразования из строки в число"); }
Если у нас возникает исключение определенного типа, то оно переходит к соответствующему блоку catch.
Оператор throw
Чтобы сообщить о выполнении исключительных ситуаций в программе, можно использовать оператор throw . То есть с помощью этого оператора мы сами можем создать исключение и вызвать его в процессе выполнения. Например, в нашей программе происходит ввод числа, и мы хотим, чтобы, если число больше 30, то возникало исключение:
Package firstapp; import java.util.Scanner; public class FirstApp { public static void main(String args) { try{ Scanner in = new Scanner(System.in); int x = in.nextInt(); if(x>=30){ throw new Exception("Число х должно быть меньше 30"); } } catch(Exception ex){ System.out.println(ex.getMessage()); } System.out.println("Программа завершена"); } }
Здесь для создания объекта исключения используется конструктор класса Exception, в который передается сообщение об исключении. И если число х окажется больше 29, то будет выброшено исключение и управление перейдет к блоку catch.
В блоке catch мы можем получить сообщение об исключении с помощью метода getMessage() .
Исключениями или исключительными ситуациями (состояниями) называются ошибки, возникшие в программе во время её работы.
Все исключения в Java являются объектами. Поэтому они могут порождаться не только автоматически при возникновении исключительной ситуации, но и создаваться самим разработчиком.
Иерархия классов исключений:
Исключения делятся на несколько классов, но все они имеют общего предка — класс Throwable. Его потомками являются подклассы Exception и Error.
Исключения (Exceptions) являются результатом проблем в программе, которые в принципе решаемы и предсказуемы. Например, произошло деление на ноль в целых числах.
Ошибки (Errors) представляют собой более серьёзные проблемы, которые, согласно спецификации Java, не следует пытаться обрабатывать в собственной программе, поскольку они связаны с проблемами уровня JVM. Например, исключения такого рода возникают, если закончилась память, доступная виртуальной машине. Программа дополнительную память всё равно не сможет обеспечить для JVM.
В Java все исключения делятся на три типа: контролируемые исключения (checked) и неконтролируемые исключения (unchecked), к которым относятся ошибки (Errors) и исключения времени выполнения (RuntimeExceptions, потомок класса Exception).
Контролируемые исключения представляют собой ошибки, которые можно и нужно обрабатывать в программе, к этому типу относятся все потомки класса Exception (но не RuntimeException).
Обработка исключения может быть произведена с помощью операторов try…catch, либо передана внешней части программы. Например, метод может передавать возникшие в нём исключения выше по иерархии вызовов, сам его не обрабатывая.
Неконтролируемые исключения не требуют обязательной обработки, однако, при желании, можно обрабатывать исключения класса RuntimeException.
Откомпилируем и запустим такую программу:
Class Main { public static void main(String args) { int a = 4; System.out.println(a/0); } }
В момент запуска на консоль будет выведено следующее сообщение:
Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main(Main.java:4)
Из сообщения виден класс случившегося исключения — ArithmeticException. Это исключение можно обработать:
Class Main { public static void main(String args) { int a = 4; try { System.out.println(a/0); } catch (ArithmeticException e) { System.out.println("Произошла недопустимая арифметическая операция"); } } }
Теперь вместо стандартного сообщения об ошибке будет выполняться блок catch, параметром которого является объект e соответствующего исключению класса (самому объекту можно давать любое имя, оно потребуется в том случае, если мы пожелаем снова принудительно выбросить это исключение, например, для того, чтобы оно было проверено каким-то ещё обработчиком).
В блок try при этом помещается тот фрагмент программы, где потенциально может возникнуть исключение.
Одному try может соответствовать сразу несколько блоков catch с разными классами исключений.
Import java.util.Scanner; class Main { public static void main(String args) { int m = {-1,0,1}; Scanner sc = new Scanner(System.in); try { int a = sc.nextInt(); m[a] = 4/a; System.out.println(m[a]); } catch (ArithmeticException e) { System.out.println("Произошла недопустимая арифметическая операция"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Обращение по недопустимому индексу массива"); } } }
Если запустив представленную программу, пользователь введётся с клавиатуры 1 или 2, то программа отработает без создания каких-либо исключений.
Если пользователь введёт 0, то возникнет исключение класса ArithmeticException, и оно будет обработано первым блоком catch.
Если пользователь введёт 3, то возникнет исключение класса ArrayIndexOutOfBoundsException (выход за приделы массива), и оно будет обработано вторым блоком catch.
Если пользователь введёт нецелое число, например, 3.14, то возникнет исключение класса InputMismatchException (несоответствие типа вводимого значение), и оно будет выброшено в формате стандартной ошибки, поскольку его мы никак не обрабатывали.
Можно, однако, добавить обработчик для класса Exception, поскольку этот класс родительский для всех остальных контролируемых исключений, то он будет перехватывать любые из них (в том числе, и InputMismatchException).
Import java.util.Scanner; class Main { public static void main(String args) { int m = {-1,0,1}; int a = 1; Scanner sc = new Scanner(System.in); try { a = sc.nextInt(); m = 4/a; System.out.println(m[a]); } catch (ArithmeticException e) { System.out.println("Произошла недопустимая арифметическая операция"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Обращение по недопустимому индексу массива"); } catch (Exception e) { System.out.println("Произошло ещё какое-то исключение"); } } }
Поскольку исключения построены на иерархии классов и подклассов, то сначала надо пытаться обработать более частные исключения и лишь затем более общие. То есть поставив первым (а не третьим) блок с обработкой исключения класса Exception, мы бы никогда не увидели никаких сообщений об ошибке, кроме «Произошло ещё какое-то исключение» (все исключения перехватились бы сразу этим блоком и не доходили бы до остальных).
Необязательным добавлением к блокам try…catch может быть блок finally. Помещенные в него команды будут выполняться в любом случае, вне зависимости от того, произошло ли исключение или нет. При том, что при возникновении необработанного исключения оставшаяся после генерации этого исключения часть программы — не выполняется. Например, если исключение возникло в процессе каких-то длительных вычислений, в блоке finally можно показать или сохранить промежуточные результаты.
2010, Алексей Николаевич Костин. Кафедра ТИДМ математического факультета МПГУ.
О чем и зачем эта статья?
В статье рассказывается об исключениях в языке Java, методах их обработки и некоторых особенностях работы с исключениями. Статья написана для семинара по технологиям Java, проводимого компанией i.Point .
Что такое исключения?
Исключения или исключительные события, это события, нарушающие нормальный ход выполнения программы.
Итак, каждый раз, когда при выполнении программы происходит ошибка, то программа выбрасывает исключение - в этот момент создается специальный объект-исключение (exception-object), дальше будем называть его просто исключение. Этот объект содержит информацию о возникшей ошибке: тип ошибки, а также запись о состоянии программы на момент возникновения ошибки. Создание исключения и передача его среде выполнения называется выбрасыванием исключения (exception throwing). Посмотрим, как происходит выброс исключений при выполнении программы в Java:
Во время выполнения первого метода возникла какая-то проблема, после этого было сгенерировано исключение. В момент генерации исключения Java начинает искать для него подходящий обработчик (handler), передавая объект вверх по стеку вызовов до тех пор, пока обработчик исключения не будет найден.
Типы исключений в Java
Взглянем на иерархию классов объектов-исключений в Java:
Как мы видим, все исключения имеют общего предка - Throwable. Он имеет два важных подкласса - Exception и Error. Исключения (Exceptions) являются результатом возникших внутри программы проблем, которые в принципе решаемы и предсказуемы. Ошибки (Errors) представляют собой более серьёзные проблемы, которые, согласно спецификации Java, не следует пытаться перехватить в приложении, написанном достаточно рационально (например ошибка OutOfMemoryError происходит в тех случаях, когда JVM не хватает памяти для выполнения программы). Кроме того, у Exception есть важный потомок - RuntimeException (исключение времени выполнения). Этот класс и его потомки представляют собой исключения, которые возникают во время "нормальной работы Java-машины" (примерами таких исключений являются попытки использования нулевых ссылок на объекты, деления на ноль или выход за границы массива).
В Java все исключения делятся на три типа: контролируемые исключения(checked), ошибки (Errors) и исключения времени выполнения (RuntimeExceptions) - последние два типа также объединяют в категорию неконтролируемых (unchecked) исключений. В чем различие? Все очень просто контролируемые исключения представляют собой те ошибки, которые могут быть обработаны в ходе выполнения программы, как вы уже догадались к этому типу относятся все потомки класса Exception (но не RuntimeException). Контролируемые исключения обязательны для обработки в коде программы, они должны быть обработаны либо включением в блок try-catch, либо объявлены в сигнатуре метода.
Неконтролируемые (unchecked) исключения не требуют обязательной обработки, поскольку представляют собой те ситуации, когда ошибка не зависит непосредственно от программиста (например произошёл сбой в аппаратном обеспечении), либо те, когда ошибку обрабатывать не имеет смысла, т.к. проще внести изменения в код - к ним относятся все потомки классов Error и RuntimeException.
Как обрабатывать исключения?
Все современные реализации языка Java придерживаются принципа обработки или объявления исключений (The Catch or Specify Requirement), который гласит, что код, который потенциально может сгенерировать контроллируемое исключение должен либо быть заключен в блок try-catch (таким образом в блоке catch мы предоставляем обработчик для исключительной ситуации), либо мы должны объявить , что наш метод может выбросить такое исключение (после ключевого слова throws, после имени метода).
Рассмотрим несколько примеров:
// Note: This class won"t compile by design! import java . io .*; import java . util . Vector ; public class ListOfNumbers { private Vector vector ; private static final int SIZE = 10 ; public ListOfNumbers () { vector = new Vector (SIZE ) ; for (int i = 0 ; i < SIZE ; i ++ ) { vector . addElement (new Integer (i )) ; } } public void writeList () { < SIZE ; i ++ ) { out . println (" Value at: " + i + " = " + vector . elementAt (i )) ; } out . close () ; } }
Этот код не скомпилируется, т.к. конструктор FileWriter требует от нас обработать IOException. Правильно написанный код должен выглядеть примерно так:
Try { //Необработанное контролируемое (checked) исключение IOException PrintWriter out = new PrintWriter (new FileWriter (" OutFile.txt " )) ; for (int i = 0 ; i < SIZE ; i ++ ) { // метод elementAt выбрасывает неконтролируемое исключение ArrayIndexOutOfBoundsException out . println (" Value at: " + i + " = " + vector . elementAt (i )) ; } catch (IOException e ){ //Пытаемся как-то исправить ситуацию, если ошибка возникла при создании файла OutFile.txt } catch (Exception e ){ //В случае если в блоке try будет сгенерировано не IOException, то управление перейдет сюда } finally { //В любом случае нам необходимо закрыть файл. if (out != null ){ out . close () ; } }
Таким образом мы обрабатываем исключение IOException. Обратите внимание на порядок объявления блоков catch - если поменять их местами, то код не скомпилируется, т.к. IOException подкласс Exception, то код обработки IOException станет недостижимым и компилятор выдаст ошибку. Особого внимания заслуживает блок finally - код в этом блоке выполняется всегда, независимо от того, что произошло в блоках try и catch.
Кроме непосредственно обработки исключения с помощью блока try-catch мы можем просто его объявить, предоставив пользователям метода самим разбираться с этой проблемой:
Public void writeList () throws IOException { //теперь нам не нужно самим обрабатывать исключение. }
Обрабатывать или объявлять?
Когда нам следует обрабатывать исключения, а когда объявлять? Очень простой вопрос.. жаль что на него нет однозначного ответа. В целом, следует придерживаться следующего правила:
Обрабатывайте исключение, когда вы можете это сделать; объявляйте исключение, когда вы вынуждены так поступить.
Что из этого следует? В основном, метод должен передавать исключение вызвавшей программе только в том случае, если он сам не обладает информацией, достаточной для обработки исключения.
Преимущества, которые дает нам использование исключений
написать тут про errorcodes и раскрыть списочег
- Разделение обычного кода и кода обработки ошибок
- Возможность передачи исключений для обработки вверх по стеку вызовов
- Группировка и обработка ошибок по типам
Проблемы, связанные с обработкой исключений
"Потерянные исключения"
Вообще, исключения в Java очень удобны и просты, но, к сожалению, и у них есть недостаток. Хотя исключения являются индикаторами проблем в программе и не должны игнорироваться, возможна ситуация, при которой исключение просто потеряется. Это может произойти, если мы неправильно напишем код в блоке finally. Рассмотрим простой пример:
// Как может быть потеряно исключение. class VeryImportantException extends Exception { public String toString () { return " A very important exception! " ; } } class HoHumException extends Exception { public String toString () { return " A trivial exception " ; } } public class LostMessage { void f () throws VeryImportantException { throw new VeryImportantException () ; } void dispose () throws HoHumException { throw new HoHumException () ; } public static void main (String args ) throws Exception { LostMessage lm = new LostMessage () ; try { lm . f () ; } finally { lm . dispose () ; } } }
Что же мы получим в результате выполнения этого кода?
Exception in thread "main" A trivial exception
at LostMessage.dispose(LostMessage.java:21)
at LostMessage.main(LostMessage.java:29)
О ужас, мы потеряли очень важное для нас VeryImportantException, получив вместо него менее значительное.
Поэтому при написании кода в блоке finally нужно быть очень осторожными, чтобы не происходило подобных потерь информации.
Одно из стандартных требований ТЗ на разработку ПО – отсутствие ошибок и конфликтов, препятствующих нормальной работе. Путей реализации два – ограничить функциональность и возможности пользователя или создать код, который будет учитывать возможные неприятности.
В java исключением называется любая ошибка, которая возникает в ходе выполнения программы. Это может быть несоответствие типов данных, деление на ноль, обрыв связи с сервером и многое другое. Операции по их поиску и предотвращению называются обработкой исключений.
Иерархия
Прежде чем мы перейдём к практике, давайте познакомимся с видами исключений Джава и их иерархией. В основе всего лежит класс Throwable. Все возможные конфликты кода с машиной и пользователем описаны здесь. Для удобства обработки и чтения класс Throwable имеет подклассы Error и Exception. Error – критические ошибки, которые не обязательно происходят по вине пользователя, обработать их невозможно. Exception – собственно конфликты нашей программы, которые необходимо отлавливать.
Взгляните на упрощённую схему иерархии исключений java:
Как видно, блоки делятся на «два лагеря» по цветам - проверяемые и непроверяемые java исключения. Данная классификация показывает, как их воспринимает компилятор: проверяемые – учитывает, непроверяемые – игнорирует. К первому относится Exception в полном составе, кроме RuntimeException. Все остальные классы исключений – непроверяемые компилятором.
Иерархия классов исключений важна и для правильной организации кода. Допустим, у вас есть несколько блоков обработки. Тогда в начале необходимо указать низшие уровни, а в конце – высшие. В противном случае, будет запущен только первый блок, а остальные – проигнорированы.
Создание обработчика
Для обработки исключений java используются следующие операторы: try, catch, finally, throw, throws. Первые три - стандартная структура вашего блока. По шагам:
- Оператор или часть кода, в которой вам надо отыскать ошибку, помещается в блок try.
- Далее в блоке catch вы указываете, что за исключение надо ловить и как его обрабатывать.
- В блоке finally набор обязательных действий при возникновении ошибки. Обычно это запись данных, закрытие ресурсов и пр. Блок исполняется всегда, вне зависимости от срабатывания catch.
Рассмотрим структуру на примере Джава исключения:
try {
}
catch (тип_исключения объект_исключения) {
// код обработки
}
finally {
}
Если вы хотите обработать несколько исключений – просто создайте ещё один блок catch.
try {
// код, где мы хотим отследить ошибку
}
catch (тип_исключения_1 объект_исключения_1) {
// код обработки
}
catch (тип_исключения_2 объект_исключения_2) {
// код обработки
}
finally {
// что нужно выполнить после завершения блока try
}
С помощью оператора throw вы можете создавать исключения:
throw экземпляр_Throwable
На практике это выглядит так:
Student stud1;
if(stud1 == null){
}
}
Включим оператор 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, он осуществляет его поиск в родительском операторе. Если и там нет – блок обрабатывается системой.
Готовые и новые исключения
- ArithmeticException - ошибки вычислений.
- NullPointerException - ссылка на пустое место.
- NegativeArraySizeException - массив отрицательной размерности.
- ArrayStoreException - присвоение элементу массива неправильного типа.
- NumberFormatException - невозможно преобразовать строку в число.
- IllegalArgumentException - неправильный аргумент при вызове метода.
- UnsupportedOperationException - указанной операции не существует.
- TypeNotPresentException - указанного типа не существует.
Все указанные типы java исключений содержатся в классе RuntimeException, а значит, их не надо указывать в блоке throws.
Естественно, система не может содержать всевозможные исключения. Некоторые придётся создавать самостоятельно. Для того, чтобы создать собственное java исключение, вам необходимо унаследовать собственный класс от Exception и переопределить требуемые методы класса Throwable. Или унаследоваться от наиболее близкого по смыслу типа. Рассмотрим на примере программы под android создание java исключения:
package geekbrains.exception;
Import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
Public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
Public void testMethod() throws StudentException {
System.out.println("Возбуждаем StudentException из метода testMethod()");
throw new StudentException(); // конструктор по умолчанию
}
Public void testMethod2() throws StudentException {
System.out.println("Возбуждаем StudentException из метода testMethod2()");
throw new StudentException("Создано во втором методе");
}
Public void onClick(View view) {
try {
testMethod();
e.printStackTrace();
System.out.println("Исключение перехвачено");
}
Try {
testMethod2();
} catch (StudentException e) {
e.printStackTrace();
}
}
Class StudentException extends Exception {
StudentException() {
}
StudentException(String msg) {
super(msg);
}
}
}
Обработка исключений – основа безопасного и качественного кода. С их помощью вы можете управлять действиями пользователя, ходом выполнения программы или добавить вариативности коду.
Любая программа будет работать стабильно только в том случае, если её исходный код отлажен, и в нем отсутствуют условия, которые могут вызывать непредвиденные ситуации. Процесс отлова возможных сбоев выполняется на стадии программирования. Для этого разработчик учитывает все предполагаемые исходы и пытается ограничить действие ошибки таким образом, чтобы она не смогла нарушить работу программы или привести к её краху.
Когда может понадобиться обработка исключений
В Java исключения могут быть вызваны в результате неправильного ввода данных пользователем, отсутствия необходимого для работы программы ресурса или внезапного отключения сети. Для комфортного использования созданного разработчиком приложения, необходимо контролировать появление внештатных ситуаций. Потребитель не должен ждать завершения работы зависшей программы, терять данные в результате необработанных исключений или просто часто появляющихся сообщений о том, что что-то пошло не так.
Обработка исключений Java
Что необходимо учитывать? Язык Java обладает своим встроенным функционалом обработки исключений. Конечно же большой процент ошибок отлавливается ещё на стадии компиляции, когда система автоматически сообщит о том, что использовать её дальше невозможно. Но существует и такой вид исключений, который возникает во время работы программы. Разработчик должен суметь предвидеть это и спроектировать код таким образом, чтобы он не вызвал ошибки, а обработал её особым способом или передал управление в другую ветку.
В Java такой отлов исключений навязывается компилятором, поэтому типичные проблемы известны и имеют свою стандартную схему исполнения.
Типичные исключения
Самым простым примером, при котором можно получить исключение — это деление. Несмотря на всю его простоту, в выражении, в качестве делителя, может оказаться ноль, что приведёт к ошибке. Хорошо, если его появление можно предсказать ранее и предотвратить. Но такой вариант доступен не всегда, поэтому отлов исключения нужно организовать непосредственно при возникновении «деления на ноль».
В Java механизм обработки перехвата ошибки выглядит так:
- в куче создаётся объект исключения, так же как и любой другой;
- естественный ход программы прерывается;
- механизм исключения пытается найти альтернативный способ продолжения кода;
- найдя место безопасного исполнения программы в обработчике, работа либо восстановится, либо произойдёт реализация исключения особым способом.
Простейший пример создания ошибки может выглядеть таким образом:
throw new NullPointerException();
Здесь переменная a проверяется на инициализацию, т.е. не равна ли ссылка на объект null. В случае, если такая ситуация возникла и нужна особая обработка, выбрасывается исключение с помощью throw new NullPointerException().
Немного подробностей о ключевых словах
При работе с исключениями часто приходится использовать ключевые слова Java для обозначения того или иного действия. В данном языке программирования их пять:
- Try. уже встречалось и означает оно переход в участок кода, который может сгенерировать исключение. Блок ограничивается фигурными скобками {}.
- Catch. Перехватывает нужный тип исключения и обрабатывает его соответствующим образом.
- Finally. Данное ключевое слово является дополнительным и служит для выполнения некоего участка кода, который необходим в любом случае, даже если ни одно исключение не перехвачено. Добавляется непосредственно после блока try.
- Throw — позволяет создавать исключения Java в любом месте кода.
- Throws — ключевое слово, которое ставится в сигнатуре метода. Оно означает, что последующий код может выбросить исключение Java указанного типа. Такая метка служит сигналом для разработчиков, что нужно иметь в виду — метод может сработать не так, как от него ожидают.
Отлов с помощью try
Выброс в Java исключения, естественно предполагает, что оно будет особым образом обработано. Удобнее всего это сделать, если участок кода отгорожен в некий блок. Который возможно содержит исключение. При выполнении такого кода виртуальная машина найдёт непредвиденную ситуацию, поймёт, что находится в критическом блоке и передаст управление в участок с обработкой.
В Java код заворачивается в специальный блок try, внутри которого может быть сгенерировано исключение. Таким образом, в него помещается сразу несколько непредвиденных ситуаций, которые будут отловлены в одном месте, не расползаясь по коду.
Самый типичный код с блоком обработки выглядит так:
//Здесь будет определён код, который может породить исключение
} catch (Тип_исключения_1 идентификатор_1) {
} catch (Тип_исключения_2 идентификатор_2) {
//Здесь происходит обработка исключения, согласно его типу и условиям;
Ключевое слово catch сообщает о том, что код, подвергнутый проверке на исключение, нужно обработать так, как описано далее, при условии, что он соответствует его типу. Идентификатор может использоваться внутри блока кода обработки как аргументы.
Finally
Как стало понятно из предыдущей главы, блоки catch ловят исключения и обрабатывают их. Но очень часто возникает ситуация, когда должен выполниться некий код вне зависимости от того, были ли отловлены ошибки. Для этого существует ключевое слово finally. Оно применяется для увеличения значений различных счётчиков, закрытия файлов или соединений с сетью.
В данном участке представлены несколько блоков catch с придуманными методами отлова исключений. К примеру, код, содержащийся в try порождает непредвиденную ситуацию типа Cold. Тогда в консоль будут выведены выражения «Caught cold!» и «Is that something to cheer about?». То есть блок finally выполняется в любом случае.
На самом деле способ избежать запуска finally существует. Связан он с завершением работы виртуальной машины. Найти, как это реализовать, можно на просторах сети Интернет.
Ключевое слово throw
Throw генерирует исключение. Его синтаксис выглядит так:
throw new NewException();
Здесь создаётся новое исключение с типом NewException(). В качестве типа могут использоваться уже входящие в стандартные библиотеки Java классы и определённые ранее разработчиком собственного производства.
Такая конструкция входит в описание какого-либо метода, вызов которого затем должен происходить в рамках блока try, для того, чтобы была возможность его перехватить.
Ключевое слово throws
Что делать, если в процессе разработки возникла ситуация, когда метод может сгенерировать исключение, но не в состоянии правильно обработать. Для этого в сигнатуре метода указывается слово throws и тип возможного исключения.
Эта метка является своеобразным указателем для клиентских разработчиков о том, что метод не способен обработать своё же исключение. К тому же, если тип ошибки является проверяемым, то компилятор заставит явно это указать.
Try с ресурсами
В Java версии 7 разработчики включили такое важное нововведение, как обработка блока try с ресурсами.
Многие создаваемые объекты в Java, после их использования должны быть закрыты для экономии ресурсов. Раньше приходилось это учитывать и останавливать такие экземпляры вручную. Теперь же в них появился интерфейс AutoClosable. Он помогает автоматически закрывать уже использованные объекты, помещённые в блок try. Благодаря такому подходу писать код стало удобней, в его читаемость значительно повысилась.
Собственные классы исключений Java
Создатели описываемого языка программирования учли многие аспекты при проектировании типов непредвиденных ситуаций. Однако, все варианты исхода событий предотвратить не получится, поэтому в Java реализована возможность определения своих собственных исключений, подходящих именно под нужды конкретного кода.
Простейший способ создания — унаследовать от наиболее подходящего к контексту объекта.
Здесь произошло наследование от Exception, класса, который используется для определения собственных исключений. В MyException имеются два конструктора — один по умолчанию, второй — с аргументом msg типа String.
Затем в public классе FullConstructors реализован метод f, сигнатура которого содержит throws MyException. Это ключевое слово означает, что f может выбросить исключение Java типа MyException. Далее в теле метода производится вывод текстовой информации в консоль и собственно сама генерация MyException, посредством throw.
Второй метод немного отличается от первого тем, что при создании исключения, ему передается строковый параметр, который будет отражён в консоли при отлове. В main видно, что f() и g() помещены в блок проверки try, а ключевое слово catch настроено на отлов MyException. Результатом обработки будет вывод сообщения об ошибке в консоль:
Таким образом получилось добавить исключения Java, созданные собственноручно.
Архитектура исключений
Как и все объекты в Java, исключения также наследуются и имеют иерархическую структуру. Корневым элементом всех ошибок, выбрасываемых в этом языке программирования является класс java.lang.Throwable. От него наследуются два вида — Error и Exception.
Error — оповещает о критических ошибках и представляет собой непроверяемые исключения Java. Перехват и обработка таких данных в большинстве случаев происходит на стадии разработки и не нуждается во внедрении в код конечного приложения.
Наиболее часто используемым классом для создания и анализа исключений служит Exception. Который, в свою очередь, делится на несколько веток, в том числе RuntimeException. К RuntimeException относятся исключения времени выполнения, то есть происходящие во время работы программы. Все унаследованные от него классы являются непроверяемыми.
Часто встречаемые исключения
В Java исключения, список которых представлен ниже, используются наиболее часто, поэтому стоит описать каждый из них подробней:
- ArithmeticException. Сюда входят ошибки связанные с арифметическими операциями. Самый яркий пример — деление на ноль.
- ArrayIndexOutOfBoundsException — обращение к номеру элемента массива, который превышает общую его длину.
- ArrayStoreException — попытка присвоить элементу массива несовместимого типа.
- ClassCastException — попытка неправильного приведения одного типа к другому.
- IllegalArgumentException — использование неправильного аргумента в вызове метода.
- NegativeArraySizeException — исключение при создании массива отрицательного размера.
- NullPointerException — неправильное использование ссылки на null.
- NumberFormatException — возникает при неверном преобразовании строки в число.
- UnsupportedOperationException — операция не поддерживается.
Данные примеры представляют собой непроверяемые типы исключений Java. А вот так выглядят проверяемые:
- ClassNotFoundException — класс не обнаружен.
- IllegalAcccessException — ограничение доступа к классу.
- InterruptedException — прерывание работы потока.
- NoSuchFieldException — не существует требуемое поле.
Интерпретация исключений
Говоря о часто встречаемых исключениях нужно отметить, что их интерпретация в ходе разработки, может быть воспринята неправильно. Далее идёт небольшой список, поясняющий более подробно, когда может возникнуть непредвиденная ситуация.
NullPointerException. Самым первым случаем, когда возникает исключение, является обращение к ссылке на объект, которая равна null. Также это распространяется на методы нулевого экземпляра класса. NullPointerException может быть брошен и в случае получения длины массива равной null. Избежать таких ситуаций поможет периодическая проверка объектов на null.
ArrayIndexOutOfBoundsException. Любая программа не может существовать без использования массивов. Соответственно, частое обращение к ним может порождать и ошибки. Возникает исключение, когда разработчик пытается обратиться к элементу массива, который отсутствует в списке индексов. Например, запрашиваемое значение выше длины или меньше нуля. Очень часто появляется в результате того, что счёт в массиве начинается с нуля.
Выводы
Обработка исключений Java — мощный инструмент среды, который значительно облегчает работу программиста и позволяет ему создавать чистый и лишенный ошибок код. От того, насколько плавно и стабильно функционирует приложение, зависит статус и репутация компании-разработчика.
Конечно, в более или менее простых программах отследить внештатные ситуации гораздо проще. А вот в больших автоматизированных комплексах на несколько сотен тысяч строк такое возможно только в результате проведения длительной отладки и тестирования.
За Java исключения, ошибки от которых возникают в некоторых приложениях, отдельные компании предлагают вознаграждение при их нахождении энтузиастами. Особенно ценятся те, которые вызывают нарушение политики безопасности программного комплекса.
