Блоки перехвата исключения
Мы можем перехватить и обработать исключение в программе. При описании обработки применяется бейсбольная терминология. Говорят, что исполняющая система или программа "выбрасывает" (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 и вообще без аргумента. Результат показан на рис. 16.2.
Рис. 16.2.
Сообщения обработки исключений
После первого запуска, при обычном ходе программы, выводятся все сообщения.
После второго запуска, приводящего к делению на нуль, управление сразу
Же передается В соответствующий блок catch(ArithmeticException ае) {},
потом выполняется то, что написано в блоке finally{}.
После третьего запуска управление после выполнения метода parseinto передается В другой блок catch(ArraylndexOutOfBoundsException arre){}, затем в блок finally{}.
Обратите внимание, что во всех случаях — и при обычном ходе программы, и после этих обработок — выводится сообщение "After all actions". Это свидетельствует о том, что выполнение программы не прекращается при возникновении исключительной ситуации, как это было в программе листинга 16.1, а продолжается после обработки и выполнения блока finally*}.
При записи блоков обработки исключений надо совершенно четко представлять себе, как будет передаваться управление во всех случаях. Поэтому изучите внимательно рис. 16.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, убедимся, что вывод программы не изменился, он такой же, как на рис. 16.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. Результат — на рис. 16.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 этот оператор показан как комментарий. Уберите символы комментария //, перекомпилируйте программу и посмотрите, как изменится ее вывод.
Рис. 16.3.
Обработка исключения в методе
Иерархия классов-исключений
Все классы-исключения расширяют класс 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.
Оператор 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. Как видно на рис. 16.4, этот блок перехватывает оба исключения. Почему? Потому что это исключения подклассов класса RuntimeException.
Рис. 16.4.
Перехват нескольких типов исключений
Таким образом, перемещаясь по иерархии классов-исключений, мы можем обрабатывать сразу более или менее крупные совокупности исключений. Рассмотрим подробнее иерархию классов-исключений.
Порядок обработки исключений
Блоки 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. На рис. 16.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();
}
}
}
Рис. 16.5.
Обработка собственного исключения
Обработка исключительных ситуаций стала сейчас
Обработка исключительных ситуаций стала сейчас обязательной частью объектно-ориентированных программ. Применяя методы классов J2SDK и других пакетов, обращайте внимание на то, какие исключения они выбрасывают, и обрабатывайте их. Исключения резко меняют ход выполнения программы, делают его запутанным. Не увлекайтесь сложной обработкой, помните о принципе KISS.
Например, из блока finally!} можно выбросить исключение и обработать его в другом месте. Подумайте, что произойдет в этом случае с исключением, возникшем в блоке try{}? Оно нигде не будет перехвачено и обработано.
