Обработка исключительных ситуаций


Исключительные ситуации (exceptions) могут возникнуть во время выполнения (runtime) программы, прервав ее обычный ход. К ним относится деление на нуль, отсутствие загружаемого файла, отрицательный или вышедший за верхний предел индекс массива, переполнение выделенной памяти и масса других неприятностей, которые могут случиться в самый неподходящий момент.
Конечно, можно предусмотреть такие ситуации и застраховаться от них как-нибудь так:
if (something == wrong){
// Предпринимаем аварийные действия 
}else{
// Обычный ход действий 
}
Но при этом много времени уходит на проверки, и программа превращается в набор этих проверок. Посмотрите любую штатную производственную программу, написанную на языке С или Pascal, и увидите, что она на 2/3 состоит из таких проверок.
В объектно-ориентированных языках программирования принят другой подход. При возникновении исключительной ситуации исполняющая система создает объект определенного класса, соответствующего возникшей ситуации, содержащий сведения о том, что, где и когда произошло. Этот объект передается на обработку программе, в которой возникло исключение. Если программа не обрабатывает исключение, то объект возвращается обработчику по умолчанию исполняющей системы. Обработчик поступает очень просто: выводит на консоль сообщение о произошедшем исключении и прекращает выполнение программы.
Приведем пример. В программе листинга 16.1 может возникнуть деление на нуль, если запустить ее с аргументом 0. В программе нет никаких средств обработки такой исключительной ситуации. Посмотрите на  1, какие сообщения выводит исполняющая система Java.
Листинг 16.1. Программа без обработки исключений
class SimpleExt {
public static void main(String[] args)({ 
int n = Integer.parselnt(args[0]); 
System.out.println("10 / n = " + (10 / n)); 
System.out.println("After all actions"); 

}
Программа SimpleExt запущена три раза. Первый раз аргумент args[0] равен 5 и программа выводит результат: "ю / n = 2". После этого появляется второе сообщение: "After all actions".
Второй раз аргумент равен о, и вместо результата мы получаем сообщение о том, что в подпроцессе "main" произошло исключение класса ArithmeticException вследствие деления на нуль: "/ by zero". Далее уточняется, что исключение возникло при выполнении метода main класса SimpleExt, а в скобках указано, что действие, в результате которого возникла исключительная ситуация, записано в четвертой строке файла SimpleExt.java. Выполнение программы прекращается, заключительное сообщение не появляется.
Третий раз программа запущена вообще без аргумента. В массиве argsn нет элементов, его длина равна нулю, а мы пытаемся обратиться к элементу args [0]. Возникает исключительная ситуация класса ArrayindexOutofBoundsException вследствие действия, записанного в третьей строке файла SimpleExt.java. Выполнение программы прекращается, обращение к методу printino не происходит.
Блоки перехвата исключения
Мы можем перехватить и обработать исключение в программе. При описании обработки применяется бейсбольная терминология. Говорят, что исполняющая система или программа "выбрасывает" (throws) объект-исключение. Этот объект "пролетает" через всю программу, появившись сначала в том методе, где произошло исключение, а программа в одном или нескольких местах пытается (try) его "перехватить" (catch) и обработать. Обработку можно сделать полностью в одном месте, а можно обработать исключение в одном месте, выбросить снова, перехватить в другом месте и обрабатывать дальше.
Мы уже много раз в этой книге сталкивались с необходимостью обрабатывать различные исключительные ситуации, но не делали этого, потому что не хотели отвлекаться от основных конструкций языка. Не вводите это в привычку! Хорошо написанные объектно-ориентированные программы обязательно должны обрабатывать все возникающие в них исключительные ситуации.
Для того чтобы попытаться (try) перехватить (catch) объект-исключение, надо весь код программы, в котором может возникнуть исключительная ситуация, охватить оператором try{} catch о {}. Каждый блок catchou перехватывает исключение только одного типа, того, который указан в его аргументе. Но можно написать несколько блоков catch(){} для перехвата нескольких типов исключений.
Например, мы знаем, что в программе листинга 16.1 могут возникнуть исключения двух типов. Напишем блоки их обработки, как это сделано в листинге 16.2.
Листинг 16.2. Программа с блоками обработки исключений
class SimpleExtlf
public static void main(String[] args){ 
try{
int n = Integer.parselnt(args[0]);
System.out.println("After parselnt());
System.out.println(" 10 / n = " + (10 / n) ) ;
Systfem. out. println ("After results output"); 
}catch(ArithmeticException ae){
System.out.println("From Arithm.Exc. catch: "+ae); 
}catch(ArraylndexOutOfBoundsException arre){
System.out.println("From Array.Exc.catch: "+arre); 
}finally{
System.out.println("From finally"); 
}
System.out.println("After all actions"); 

}
В программу листинга 16.1 вставлен блок try{} и два блока перехвата catchou для каждого типа исключений. Обработка исключения здесь заключается просто в выводе сообщения и содержимого объекта-исключения, как оно представлено методом tostring() соответствующего класса-исключения.
После блоков перехвата вставлен еще один, необязательный блок finaliy(). Он предназначен для выполнения действий, которые надо выполнить обязательно, чтобы ни случилось. Все, что написано в этом блоке, будет выполнено и при возникновении исключения, и при обычном ходе программы, и даже если выход из блока try{} осуществляется оператором return.
Если в операторе обработки исключений есть блок finally{}, то блок catch () {} может отсутствовать, т. е. можно не перехватывать исключение, но при его возникновении все-таки проделать какие-то обязательные действия.
Кроме блоков перехвата в листинге 16.2 после каждого действия делается трассировочная печать, чтобы можно было проследить за порядком выполнения программы. Программа запущена три раза: с аргументом 5, с аргументом 0 и вообще без аргумента. Результат показан на  2.
После первого запуска, при обычном ходе программы, выводятся все сообщения.
После второго запуска, приводящего к делению на нуль, управление сразу
Же передается В соответствующий блок catch(ArithmeticException ае) {}, потом выполняется то, что написано в блоке finally{}.
После третьего запуска управление после выполнения метода parseinto передается В другой блок catch(ArraylndexOutOfBoundsException arre){}, затем в блок finally{}.
Обратите внимание, что во всех случаях — и при обычном ходе программы, и после этих обработок — выводится сообщение "After all actions". Это свидетельствует о том, что выполнение программы не прекращается при возникновении исключительной ситуации, как это было в программе листинга 16.1, а продолжается после обработки и выполнения блока finally*}.
При записи блоков обработки исключений надо совершенно четко представлять себе, как будет передаваться управление во всех случаях. Поэтому изучите внимательно  2.
Интересно, что пустой блок catch (){}, в котором между фигурными скобками нет ничего, даже пробела, тоже считается обработкой исключения и приводит к тому, что выполнение программы не прекратится. Именно так мы "обрабатывали" исключения в предыдущих главах.
Немного выше было сказано, что выброшенное исключение "пролетает" через всю программу. Что это означает? Изменим программу листинга 16.2, вынеся деление в отдельный метод f (). Получим листинг 16.3.
Листинг 16.3. Выбрасывание исключения из метода
class SimpleExt2{
private static void f(int n){
System.out.println(" 10 / n = " + (10 / n)); 
}
public static void main(String[] args){ 
try{
int n = Integer.parselnt(args[0]); 
System.out.println("After parselnt()); 
f (n);
System.out.println("After results output"); 
}catch(SrithmeticException ae){
System.out.println("From Arithm.Exc. catch: "+ae); 
}catch(ArraylndexQutOfBoundsException arre){
System.out.println("From Array.Exc. catch: "+arre); 
}finally{
System,out.println("From finally"); 
}
System.out.println("After all actions"); 
}
}
Откомпилировав и запустив программу листинга 16.3, убедимся, что вывод программы не изменился, он такой же, как на  2. Исключение, возникшее при делении на нуль в методе f (), "пролетело" через этот метод, "вылетело" в метод main (), там перехвачено и обработано.
 
Часть заголовка метода throws
То обстоятельство, что метод не обрабатывает возникающее в нем исключение, а выбрасывает (throws) его, следует отмечать в заголовке метода служебным словом throws и указанием класса исключения:
private static void f(int n) throws ArithmeticException{
System.out.println(" 10 / n = " + (10 / n)) ; 
}
Почему же мы не сделали это в листинге 16.3? Дело в том, что спецификация JLS делит все исключения на проверяемые (checked), те, которые проверяет компилятор, и непроверяемые (unchecked). При проверке компилятор замечает необработанные в методах и конструкторах исключения и считает ошибкой отсутствие в заголовке таких методов и конструкторов пометки throws. Именно для предотвращения подобных ошибок мы в предыдущих главах вставляли в листинги блоки обработки исключений.
Так вот, исключения класса RuntimeException и его подклассов, одним из которых является ArithmeticException, непроверяемые, для них пометка throws необязательна. Еще одно большое семейство непроверяемых исключений составляет класс Error и его расширения.
Почему компилятор не проверяет эти типы исключений? Причина в том, что исключения класса RuntimeException свидетельствуют об ошибках в программе, и единственно разумный метод их обработки — исправить исходный текст программы и перекомпилировать ее. Что касается класса Error, то эти исключения очень трудно локализовать и на стадии компиляции невозможно определить место их появления.
Напротив, возникновение проверяемого исключения показывает, что программа недостаточно продумана, не все возможные ситуации описаны. Такая программа должна быть доработана, о чем и напоминает компилятор.
Если метод или конструктор выбрасывает несколько исключений, то их надо перечислить через запятую после слова throws. Заголовок метода main ()
листинга 16.1, если бы исключения, которые он выбрасывает, не были бы объектами подклассов класса RuntimeException, следовало бы написать так:
public static void main(String[] args)
throws ArithmeticException, ArrayIndexOutOfBoundsException{ 
// Содержимое метода 
}
Перенесем теперь обработку деления на нуль в метод f о и добавим трассировочную печать, как это сделано в листинге 16.4. Результат — на  3.
Листинг 16.4. Обработка исключения в методе
class SimpleExt3{
private static void f(int n){ // throws ArithmeticException{ 
try{
System.out.println(" 10 / n = " + (10 / n) ) ; 
System.out.printlnt"From f() after results output"); 
}catch(ArithmeticException ae)(
System.out.printlnf"From f() catch: " + ae) ; 
// throw ae; 
}finally{
System.out.println("From f() finally"); 

}
public static void main(String[] args){ 
try{
inf n = Integer.parselnt(args[0]); 
System.out.printlnt"After parselnt()); 
f (n);
System.out.println("After results output"); (
catch(ArithmeticException ae){
System.out.println("From Arithm.Exc. catch: "+ае); 
}catch(ArraylndexOutOfBoundsException arre)(
System.out.println("From Array.Exc. catch: "+arre); 
}finally{
System.out.println("From finally"); 
}
System.out.println("After all actions"); 

}
Внимательно проследите за передачей управления и заметьте, что исключение класса ArithmeticException уже не выбрасывается в метод main ().
Оператор try {}catch о {} в методе f о можно рассматривать как вложенный в оператор обработки исключений в методе main ().
При необходимости исключение можно выбросить оператором throw ae. В листинге 16.4 этот оператор показан как комментарий. Уберите символы комментария //, перекомпилируйте программу и посмотрите, как изменится ее вывод.
 
Оператор throw
Этот оператор очень прост: после слова throw через пробел записывается объект класса-исключения. Достаточно часто он создается прямо в операторе throw, например:
throw new ArithmeticException();
Оператор можно записать в любом месте программы. Он немедленно выбрасывает записанный в нем объект-исключение и дальше обработка этого исключения идет как обычно, будто бы здесь произошло деление на нуль или другое действие, вызвавшее исключение класса ArithmeticException.
Итак, каждый блок catch о и перехватывает один определенный тип исключений. Если требуется одинаково обработать несколько типов исключений, то можно воспользоваться тем, что классы-исключения образуют иерархию. Изменим еще раз листинг 16.2, получив листинг 16.5.
Листинг 16.5. Обработка нескольких типов исключений
class SimpleExt4(
public static void main(String[] args){
try{
int n = Integer.parselnt(args[0]);
System.out.println("After parselnt());
System.out.println(" 10 / n = " + (10 / n) ) ;
System.out.println("After results output"); 
}catch(RuntimeException ae){
System.out.println("From Run.Exc. catch: "+ae); 
}finally{
System.out.println("From finally"); 
}
System.out.println("After all actions"); 

}
В листинге 16.5 два блока catch() {} заменены одним блоком, перехватывающим исключение класса RuntimeException. Как видно на  4, этот блок перехватывает оба исключения. Почему? Потому что это исключения подклассов класса RuntimeException.
Таким образом, перемещаясь по иерархии классов-исключений, мы можем обрабатывать сразу более или менее крупные совокупности исключений. Рассмотрим подробнее иерархию классов-исключений.
 
Иерархия классов-исключений
Все классы-исключения расширяют класс Throwabie — непосредственное расширение класса object.
У класса Throwabie и у всех его расширений по традиции два конструктора: 

  • Throwabie о — конструктор по умолчанию;
  • Throwabie (String message) — создаваемый объект будет содержать произвольное сообщение message.

Записанное в конструкторе сообщение можно получить затем методом getMessage (). Если объект создавался конструктором по умолчанию, то данный метод возвратит null.
Метод tostringo возвращает краткое описание события, именно он работал в предыдущих листингах.
Три метода выводят сообщения обо всех методах, встретившихся по пути "полета" исключения:

  • printstackTrace() — выводит сообщения в стандартный вывод, как правило, это консоль;
  • printStackTrace(PrintStream stream) — выводит сообщения в байтовый поток stream;
  • printStackTrace(PrintWriter stream) — выводит сообщения в символьный поток stream.

У класса Throwabie два непосредственных наследника — классы Error и Exception. Они не добавляют новых методов, а служат для разделения классов-исключений на два больших семейства — семейство классов-ошибок (error) и семейство собственно классов-исключений (exception).
Классы-ошибки, расширяющие класс Error, свидетельствуют о возникновении сложных ситуаций в виртуальной машине Java. Их обработка требует глубокого понимания всех тонкостей работы JVM. Ее не рекомендуется выполнять в обычной программе. Не советуют даже выбрасывать ошибки оператором throw. He следует делать свои классы-исключения расширениями класса Error или какого-то его подкласса.
Имена классов-ошибок, по соглашению, заканчиваются словом Error.
Классы-исключения, расширяющие класс Exception, отмечают возникновение обычной нештатной ситуации, которую можно и даже нужно обработать. Такие исключения следует выбросить оператором throw. Классов-исключений очень много, более двухсот. Они разбросаны буквально по всем пакетам J2SDK. В большинстве случаев вы способны подобрать готовый класс-исключение для обработки исключительных ситуаций в своей программе. При желании можно создать и свой класс-исключение, расширив класс Exception или любой его подкласс.
Среди классов-исключений выделяется класс RuntimeException — прямое расширение класса Exception. В нем и его подклассах отмечаются исключения, возникшие при работе JVM, но не столь серьезные, как ошибки. Их можно обрабатывать и выбрасывать, расширять своими классами, но лучше
доверить это JVM, поскольку чаще всего это просто ошибка в программе, которую надо исправить. Особенность исключений данного класса в том, что их не надо отмечать в заголовке метода пометкой throws.
Имена классов-исключений, по соглашению, заканчиваются словом Exception.
Порядок обработки исключений
Блоки catch () {} перехватывают исключения в порядке написания этих блоков. Это правило приводит к интересным результатам.
В листинге 16.2 мы записали два блока перехвата catchou и оба блока выполнялись при возникновении соответствующего исключения. Это происходило по тому, что классы-исключения ArithmeticException и ArrayindexOutofBoundsException находятся на разных ветвях иерархии исключений. Иначе обстоит дело, если блоки catch() {} перехватывают исключения, расположенные на одной ветви. Если в листинге 16.4 после блока, перехватывающего RuntimeException, поместить блок, обрабатывающий выход индекса за пределы:
try{
// Операторы, вызывающие исключения 
}catch(RuntimeException re){
// Какая-то обработка 
}catch(ArrayindexOutofBoundsException ae){
// Никогда не будет выполнен! 
}
то он не будет выполняться, поскольку исключение этого типа является, к тому же, исключением общего типа RuntimeException и будет перехватываться Предыдущим блоком catch () {}.
Создание собственных исключений
Прежде всего, нужно четко определить ситуации, в которых будет возникать ваше собственное исключение, и подумать, не станет ли его перехват невольно перехватывать также и другие, не учтенные вами исключения.
Потом надо выбрать суперкласс создаваемого класса-исключения. Им может быть класс Exception или один из его многочисленных подклассов.
После этого можно написать класс-исключение. Его имя, по соглашению, должно завершаться словом Exception. Как правило, этот класс состоит только из двух конструкторов и переопределения методов tostringo и getMessageO.
Рассмотрим простой пример. Пусть метод handle(int cipher) обрабатывает арабские цифры 0—9, которые передаются ему в аргументе cipher типа int.
Мы хотим выбросить исключение, если аргумент cipher выходит за диапазон 0—9.
Прежде всего, убедимся, что такого исключения нет в иерархии классов Exception. Ко всему прочему, не отслеживается и более общая ситуация попадания целого числа в какой-то диапазон. Поэтому будем расширять наш класс. Назовем его cipherException, прямо от класса Exception. Определим класс cipherException, как показано в листинге 16.6, и используем его в классе ExceptDemo. На  5 продемонстрирован вывод этой программы.
Листинг 16.6. Создание класса-исключения
class CipherException extends Exception{ 
private String msg; 
CipherException(){ msg = null;} 
CipherException(String s){ msg = s;} 
public String toString(){
return "CipherException (" + msg + "); 


class Except Demo(
static public void handle(int cipher) throws CipherException{ 
System.out.pnntln("handle()'s beginning"); 
if (cipher < 0 || cipher > 9)
throw new CipherException("" + cipher); 
System.out.println("handle()'s ending"); 
}
public static void main(String[] args){ 
try{
handle(1) ; 
handle(10); 
}catch(CipherException ce){
System.out.println("caught " + ce) ; 
ce.printStackTrace(); 


}
 
Заключение
Обработка исключительных ситуаций стала сейчас обязательной частью объектно-ориентированных программ. Применяя методы классов J2SDK и других пакетов, обращайте внимание на то, какие исключения они выбрасывают, и обрабатывайте их. Исключения резко меняют ход выполнения программы, делают его запутанным. Не увлекайтесь сложной обработкой, помните о принципе KISS.
Например, из блока finally!} можно выбросить исключение и обработать его в другом месте. Подумайте, что произойдет в этом случае с исключением, возникшем в блоке try{}? Оно нигде не будет перехвачено и обработано.

 

 
На главную | Содержание | < Назад....Вперёд >
С вопросами и предложениями можно обращаться по nicivas@bk.ru. 2013 г. Яндекс.Метрика