Ошибка деления на ноль java - Исправление ошибок и поиск оптимальных решений проблем

I have code to calculate the percentage difference between 2 numbers — (oldNum - newNum) / oldNum * 100; — where both of the numbers are doubles. I expected to have to add some sort of checking / exception handling in case oldNum is 0. However, when I did a test run with values of 0.0 for both oldNum and newNum, execution continued as if nothing had happened and no error was thrown. Running this code with ints would definitely cause an arithmetic division-by-zero exception. Why does Java ignore it when it comes to doubles?

Aziz Shaikh

16.1k11 gold badges61 silver badges79 bronze badges

asked Mar 4, 2010 at 17:57

Java’s float and double types, like pretty much any other language out there (and pretty much any hardware FP unit), implement the IEEE 754 standard for floating point math, which mandates division by zero to return a special «infinity» value. Throwing an exception would actually violate that standard.

Integer arithmetic (implemented as two’s complement representation by Java and most other languages and hardware) is different and has no special infinity or NaN values, thus throwing exceptions is a useful behaviour there.

answered Mar 4, 2010 at 18:16

Michael BorgwardtMichael Borgwardt

340k77 gold badges478 silver badges713 bronze badges

The result of division by zero is, mathematically speaking, undefined, which can be expressed with a float/double (as NaN — not a number), it isn’t, however, wrong in any fundamental sense.

As an integer must hold a specific numerical value, an error must be thrown on division by zero when dealing with them.

RubioRic

2,4474 gold badges28 silver badges35 bronze badges

answered Mar 4, 2010 at 17:58

KrisKris

14.4k7 gold badges54 silver badges65 bronze badges

When divided by zero ( 0 or 0.00 )

If you divide double by 0, JVM will show Infinity.

public static void main(String [] args){ double a=10.00; System.out.println(a/0); }

Console:
Infinity
If you divide int by 0, then JVM will throw Arithmetic Exception.

public static void main(String [] args){ int a=10; System.out.println(a/0); }

Console: Exception in thread "main" java.lang.ArithmeticException: / by zero
But if we divide int by 0.0, then JVM will show Infinity:

public static void main(String [] args){ int a=10; System.out.println(a/0.0); }

Console: Infinity

This is because JVM will automatically type cast int to double, so we get infinity instead of ArithmeticException.

answered Oct 1, 2017 at 10:59

Raman GuptaRaman Gupta

1,53015 silver badges12 bronze badges

The way a double is stored is quite different to an int. See http://firstclassthoughts.co.uk/java/traps/java_double_traps.html for a more detailed explanation on how Java handles double calculations. You should also read up on Floating Point numbers, in particular the concept of Not a Number (NaN).

If you’re interested in learning more about floating point representation, I’d advise reading this document (Word format, sorry). It delves into the binary representation of numbers, which may be helpful to your understanding.

answered Mar 4, 2010 at 18:05

MikeMike

2,4071 gold badge24 silver badges32 bronze badges

Though Java developers know about the double primitive type and Double class, while doing floating point arithmetic they don’t pay enough attention to Double.INFINITY, NaN, -0.0 and other rules that govern the arithmetic calculations involving them.

The simple answer to this question is that it will not throw ArithmeticException and return Double.INFINITY. Also, note that the comparison x == Double.NaN always evaluates to false, even if x itself is a NaN.

To test if x is a NaN, one should use the method call Double.isNaN(x) to check if given number is NaN or not. This is very close to NULL in SQL.

It may helpful for you.

answered Feb 2, 2016 at 10:18

Источник

Aziz Shaikh

16.1k11 gold badges61 silver badges79 bronze badges

asked Mar 4, 2010 at 17:57

answered Mar 4, 2010 at 18:16

Michael BorgwardtMichael Borgwardt

340k77 gold badges478 silver badges713 bronze badges

The result of division by zero is, mathematically speaking, undefined, which can be expressed with a float/double (as NaN — not a number), it isn’t, however, wrong in any fundamental sense.

As an integer must hold a specific numerical value, an error must be thrown on division by zero when dealing with them.

RubioRic

2,4474 gold badges28 silver badges35 bronze badges

answered Mar 4, 2010 at 17:58

KrisKris

14.4k7 gold badges54 silver badges65 bronze badges

When divided by zero ( 0 or 0.00 )

If you divide double by 0, JVM will show Infinity.

public static void main(String [] args){ double a=10.00; System.out.println(a/0); }

Console:
Infinity
If you divide int by 0, then JVM will throw Arithmetic Exception.

public static void main(String [] args){ int a=10; System.out.println(a/0); }

Console: Exception in thread "main" java.lang.ArithmeticException: / by zero
But if we divide int by 0.0, then JVM will show Infinity:

public static void main(String [] args){ int a=10; System.out.println(a/0.0); }

Console: Infinity

This is because JVM will automatically type cast int to double, so we get infinity instead of ArithmeticException.

answered Oct 1, 2017 at 10:59

Raman GuptaRaman Gupta

1,53015 silver badges12 bronze badges

answered Mar 4, 2010 at 18:05

MikeMike

2,4071 gold badge24 silver badges32 bronze badges

To test if x is a NaN, one should use the method call Double.isNaN(x) to check if given number is NaN or not. This is very close to NULL in SQL.

It may helpful for you.

answered Feb 2, 2016 at 10:18

Источник

Глава 9

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

Основные навыки и понятия

Представление об иерархии исключений
Использование ключевых слов try и catch
Последствия неперехвата исключений
Применение нескольких операторов catch
Перехват исключений, генерируемых подклассами
Вложенные блоки try
Генерирование исключений
Представление о членах класса Throwable
Использование ключевого слова finally
Использование ключевого слова throws
Представление о исключениях, встроенные в Java
Создание специальных классов исключений

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

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

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

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

В Java все исключения представлены отдельными классами. Все классы исключений являются потомками класса Throwable. Так, если в программе возникнет исключительная ситуация, будет сгенерирован объект класса, соответствующего определенному типу исключения. У класса Throwable имеются два непосредственных подкласса: Exception и Error. Исключения типа Error относятся к ошибкам, возникающим в виртуальной машине Java, а не в прикладной программе. Контролировать такие исключения невозможно, поэтому реакция на них в прикладной программе, как правило, не предусматривается. В связи с этим исключения данного типа не будут описываться в этой книге.

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

Общее представление об обработке исключений

Для обработки исключений в Java предусмотрены пять ключевых слов: try, catch, throw, throws и finally. Они образуют единую подсистему, в которой использование одного ключевого слова почти всегда автоматически влечет за собой употребление другого. Каждое из упомянутых выше ключевых слов будет подробно рассмотрено далее в этой главе. Но прежде следует дать общее представление об их роли в процессе обработки исключений. Поэтому ниже поясняется вкратце, каким образом они действуют.

Операторы, в которых требуется отслеживать появление исключений, помещаются в блок try. Если в блоке try будет сгенерировано исключение, его можно перехватить и обработать нужным образом. Системные исключения генерируются автоматически. А для того чтобы сгенерировать исключение вручную, следует воспользоваться ключевым словом throw. Иногда возникает потребность обрабатывать исключения за пределами метода, в котором они возникают, и для этой цели служит ключевое слово throws. Если же некоторый фрагмент кода должен быть выполнен обязательно и независимо от того, возникнет исключение или нет, его следует поместить в блок finally.

Использование ключевых слов try и catch

Основными языковыми средствами обработки исключений являются ключевые слова try и catch. Они используются совместно. Это означает, что нельзя указать ключевое слово catch в коде, не указав ключевое слово try. Ниже приведена общая форма записи блоков try/catch, предназначенных для обработки исключений.

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

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

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

На заметку.
В версии JDK 7 внедрена новая форма оператора try, поддерживающая автоматическое управления ресурсами и называемая оператором try с ресурсами. Более подробно она описывается в главе 10 при рассмотрении потоков ввода-вывода, в том числе и тех, что связаны с файлами, поскольку потоки ввода-вывода относятся к числу ресурсов, наиболее употребительных в прикладных программах.

Простой пример обработки исключений

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

// Демонстрация обработки исключений,
class ExcDemol {
    public static void main (String args[]) {
        int nums[] = new int[4];

        // Создание блока try.
        try {
            System.out.println("Before exception is generated.");

            // Попытка обратиться за границы массива.
            nums[7] = 10;
            System.out.println("this won't be displayed");
        }
        // Перехват исключения в связи с обращением за границы массива.
        catch (ArraylndexOutOfBoundsException exc) {
            System.out.println("Index out-of-bounds!");
        }
        System.out.println("After catch statement.");
    }
}

Результат выполнения данной программы выглядит следующим образом:

Before exception is generated.
Index out-of-bounds!
After catch statement.

Несмотря на всю простоту данного примера программы, он наглядно демонстрирует несколько важных особенностей обработки исключений. Во-первых, код, подлежащий проверке на наличие ошибок, помещается в блок try. И во-вторых, когда возникает исключение (в данном случае это происходит при попытке обратиться за границы массива), выполнение блока try прерывается и управление получает блок catch. Следовательно, явного обращения к блоку catch не происходит, но переход к нему осуществляется лишь при определенном условии, возникающем в ходе выполнения программы. Так, оператор вызова метода println(), следующий за выражением, в котором происходит обращение к несуществующему элементу массива, вообще не выполняется. По завершении блока catch выполнение программы продолжается с оператора, следующего за этим блоком. Таким образом, обработчик исключений предназначен для устранения программных ошибок, приводящих к исключительным ситуациям, а также для обеспечения нормального продолжения исполняемой программы.

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

на следующую строку кода:

Теперь исключение не возникнет и блок catch не выполнится.

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

/* Исключение может быть сгенерировано одним методом,
   а перехвачено другим. */

class ExcTest {
    // сгенерировать исключение
    static void genException()  {
        int nums[] = new int[4];

        System.out.println("Before exception is generated.");

        // Здесь генерируется исключение в связи с
        // обращением за границы массива.
        nums[7] = 10;
        System.out.println("this won't be displayed");
    }
}

class ExcDemo2 {
    public static void main(String args[])  {
        try {
            ExcTest.genException() ;
        }
        //А здесь исключение перехватывается.
        catch (ArraylndexOutOfBoundsException exc) {
            System.out.println("Index out-of-bounds!");
        }
        System.out.println("After catch statement.");
    }
}

Выполнение этой версии программы дает такой же результат, как и при выполнении ее предыдущей версии. Этот результат приведен ниже.

Before exception is generated.
Index out-of-bounds!
After catch statement.

Метод genException() вызывается из блока try, и поэтому генерируемое, но не перехватываемое в нем исключение перехватывается далее в блоке catch в методе main(). Если бы метод genException() сам перехватывал исключение, оно вообще не дошло бы до метода main().

Последствия неперехвата исключений

Перехват стандартного исключения Java, продемонстрированный в предыдущем примере, позволяет предотвратить завершение программы вследствие ошибки. Генерируемое исключение должно быть перехвачено и обработано. Если исключение не обрабатывается в программе, оно будет обработано виртуальной машиной Java. Но дело в том, что по умолчанию виртуальная машина Java аварийно завершает программу, выводя сообщение об ошибке и трассировку стека исключений. Допустим, в предыдущем примере попытка обращения за границы массива не отслеживается и исключение не перехватывается, как показано ниже.

// Обработка ошибки средствами виртуальной машины Java,
class NotHandled {
    public static void main(String args[]) {
        int nums[] = new int[4];

        System.out.println("Before exception is generated.");

        // Попытка обращения за границы массива,
        nums[7] = 10;
    }
}

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

Exception in thread "main" java.lang.ArraylndexOutOfBoundsException: 7 at NotHandled.main(NotHandled.java:9)

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

Как упоминалось выше, тип исключения должен соответствовать типу, указанному в операторе catch. В противном случае исключение не будет перехвачено. Так, в приведенном ниже примере программы делается попытка перехватить исключение, связанное с обращением за границы массива, с помощью оператора catch, в котором указан тип ArithmeticException еще одного встроенного в Java исключения. При неправильном обращении к массиву будет сгенерировано исключение ArraylndexOutOfBoundsException, не соответствующее типу, указанному в операторе catch. В результате программа будет завершена аварийно.

// Эта программа не будет работать нормально!
class ExcTypeMismatch {
    public static void main(String args[]) {
        int nums[] = new int[4];
        try {
        System.out.println("Before exception is generated.");
        // При выполнении следующего оператора возникает
        // исключение ArraylndexOutOfBoundsException
        nums[7] = 10;
        System.out.println("this won’t be displayed");
        }
        /* Исключение, связанное с обращением за границы массива,
        нельзя обработать с помощью оператора catch, в котором
        указан тип исключения ArithmeticException. */
        catch (ArithmeticException exc) {
        System.out.println("Index out-of-bounds!");
        }
        System.out.println("After catch statement.");
    }
}

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

Before exception is generated.
Exception in thread "main" java.lang.ArraylndexOutOfBoundsException: 7
    at ExcTypeMismatch.main(ExcTypeMismatch.java:10)

Нетрудно заметить, что оператор catch, в котором указан тип исключения ArithmeticException, не может перехватить исключение ArraylndexOutOfBoundsException.

Обработка исключений — изящный способ устранения программных ошибок

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

// Изящная обработка исключения и продолжение выполнения программы,
class ExcDemo3 {
    public static void main(String args[])  {
        int numer[] = { 4, 8, 16, 32, 64, 128 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        for(int i=0; i<numer.length; i++)   {
            try {
                System.out.println(numer[i] + " / " +
                                   denom[i] + " is " +
                                   numer[i]/denom[i]);
            }
            catch (ArithmeticException exc) {
                // перехватить исключение
                System.out.println("Can't divide by Zero!");
            }
        }
    }
}

Результат выполнения данной программы выглядит следующим образом:

4 / 2 is 2
Can't divide by Zero!
16/ 4 is 4
32 / 4 is 8
Can't divide by Zero!
128 / 8 is 16

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

Применение нескольких операторов catch

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

// Применение нескольких операторов catch.  '
class ExcDemo4 {
    public static void main(String args[]) {
        // Здесь массив numer длиннее массива denom.
        int numer[] = { 4, 8, 16, 32, 64, 128, 256, 512 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        for(int i=0; i<numer.length; i++)   {
            try {
                System.out.println(numer[i] + " / " +
                                   denom[i] + " is " +
                                   numer[i]/denom[i]);
            }
            // За блоком try следует несколько блоков catch подряд,
            catch (ArithmeticException exc) {
                // перехватить исключение
                System.out.println("Can't divide by Zero!");
            }
            catch (ArraylndexOutOfBoundsException exc) {
                // перехватить исключение
                System.out.println("No matching element found.");
            }
        }
    }
}

Выполнение этой программы дает следующий результат:

4 / 2 is 2
Can't divide by Zero!
16 / 4 is 4
32 / 4 is 8
Can't divide by Zero!
128 / 8 is 16
No matching element found.
No matching element found.

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

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

Перехват исключений, генерируемых подклассами

В отношении подклассов следует отметить еще одну интересную особенность применения нескольких операторов catch: условие перехвата исключений для суперкласса будет справедливо и для любых его подклассов. Например, класс Throwable является суперклассом для всех исключений, поэтому для перехвата всех возможных исключений в операторах catch следует указывать тип Throwable. Если же требуется перехватывать исключения типа суперкласса и типа подкласса, то в блоке операторов первым должен быть указан тип исключения, генерируемого подклассом. В противном случае вместе с исключением типа суперкласса будут перехвачены и все исключения производных от него классов. Это правило соблюдается автоматически, и если указать первым тип исключения, генерируемого суперклассом, то будет создан недостижимый код, поскольку условие перехвата исключения, генерируемого подклассом, никогда не будет выполнено. А ведь недостижимый код в Java считается ошибкой.

Рассмотрим в качестве примера следующую программу

//В операторах catch исключения типа подкласса должны
// предшествовать исключениям типа суперкласса,
class ExcDemo5 {
    public static void main(String args[]) {
        // Здесь массив numer длиннее массива denom.
        int numer[] = { 4, 8, 16, 32, 64, 128, 256, 512 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        for(int i=0; i<numer.length; i++)   {
            try {
                System.out.println(numer[i] + " / " +
                                   denom[i] + " is " +
                                   numer[i]/denom[i]);
            }
            // Перехват исключения от подкласса.
            catch (ArraylndexOutOfBoundsException exc) {
                System.out.println("No matching element found.");
            }
            // Перехват исключения от суперкласса.
            catch (Throwable exc) {
                System.out.println("Some exception occurred.");
            }
        }
    }
}

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

4 / 2 is 2
Some exception occurred.
16 / 4 is 4
32 / 4 is 8
Some exception occurred.
128 / 8 is 16
No matching element found.
No matching element found.

В данном случае оператор catch (Throwable) перехватывает все исключения, кроме ArraylndexOutOfBoundsException. Соблюдение правильного порядка следования операторов catch приобретает особое значение в том случае, когда исключения генерируются в самой программе.

Вложенные блоки try

Блоки try могут быть вложенными друг в друга. Исключение, возникшее во внутреннем блоке try и не перехваченное связанным с ним блоком catch, распростра¬няется далее во внешний блок try и обрабатывается связанным с ним блоком catch. Такой порядок обработки исключений демонстрируется в приведенном ниже примере программы, где исключение ArraylndexOutOfBoundsException не перехватывается во внутреннем блоке catch, но обрабатывается во внешнем.

// Применение вложенных блоков try.
class NestTrys {
    public static void main(String args[]) {
        // Массив numer длиннее, чем массив denom.
        int numer[] = { 4, 8, 16, 32, 64, 128, 256, 512 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        // Вложенные блоки try.
        try { // Внешний блок try.
            for(int i=0; i<numer.length; i++)   {
                try { // Внутренний блок try.
                    System.out.println(numer[i] + " / " +
                                       denom[i] + " is " +
                                       numer[i]/denom[i]) ;
                }
                catch (ArithmeticException exc) {
                    // перехватить исключение
                    System.out.println("Can't divide by Zero!");
                }
            }
        }
        catch (ArraylndexOutOfBoundsException exc) {
            // перехватить исключение
            System.out.println("No matching element found.");
            System.out.println("Fatal error - program terminated.");
        }
    }
}

Выполнение этой программы может дать, например, следующий результат:

4 / 2 is 2
Can't divide by Zero!
16 / 4 is 4
32 / 4 is 8
Can't divide by Zero!
128 / 8 is 16
No matching element found.
Fatal error - program terminated.

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

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

Генерирование исключений

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

где объект_исключения должен быть объектом класса, производного от класса Throwable.

Ниже приведен пример программы, демонстрирующий применение оператора throw. В этой программе исключение ArithmeticException генерируется вручную.

// Генерирование исключения вручную,
class ThrowDemo {
    public static void main(String args[])  {
        try {
            System.out.println("Before throw.");
                // Генерирование исключения.
                throw new ArithmeticException() ;
        }
        catch (ArithmeticException exc) {
            // перехватить исключение
            System.out.println("Exception caught.");
        }

        System.out.println("After try/catch block.");
    }
}

Выполнение этой программы дает следующий результат:

Before throw.
Exception caught.
After try/catch block.

Обратите внимание на то, что исключение ArithmeticException генерируется с помощью ключевого слова new в операторе throw. Дело в том, что оператор throw генерирует исключение в виде объекта. Поэтому после ключевого слова throw недостаточно указать только тип исключения, нужно еще создать объект для этой цели.

Повторное генерирование исключений

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

Ниже приведен пример программы, демонстрирующий повторное генерирование исключений.

//•Повторное генерирование исключений,
class Rethrow {
    public static void genException()   {
        // Массив numer длиннее маесивв denom.
        int numer[] = { 4, 8, 16, 32, 64, 128, 256, 512 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        for(int i=0; i<numer.length; i++)   {
            try {
                System.out.println(numer[i] + " / " +
                                   denom[i] + " is " +
                                   numer[i]/denom[i]);
            }
            catch (ArithmeticException exc) {
                // перехватить исключение
                System.out.println("Can11 divide by Zero!");
            }
            catch (ArraylndexOutOfBoundsException exc) {
                // перехватить исключение
                System.out.println("No matching element found.");
                throw exc; // Повторное генерирование исключения.
            }
        }
    }
}

class RethrowDemo {
    public static void main(String args[])  {
        try {
            Rethrow.genException();
        }
        catch(ArraylndexOutOfBoundsException exc) {
            // Перехват повторно сгенерированного включения.
            System.out.println("Fatal error - " +
                               "program terminated.");
        }
    }
}

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

Подробнее о классе Throwable

В приведенных до сих примерах программ только перехватывались исключения, но не выполнялось никаких действий над представляющими их объектами. В выражении оператора catch указываются тип исключения и параметр, принимающий объект исключения. А поскольку все исключения представлены подклассами, производными от класса Throwable, то они поддерживают методы, определенные в этом классе. Некоторые наиболее употребительные методы из класса Throwable приведены в табл. 9.1.

Таблица 9.1. Наиболее употребительные методы из класса Throwable

Метод	Описание
`Throwable filllnStackTrace()`	Возвращает объект типа Throwable, содержащий полную трассировку стека исключений. Этот объект пригоден для повторного генерирования исключений
`String getLocalizedMessage()`	Возвращает описание исключения, локализованное по региональным стандартам
`String getMessage()`	Возвращает описание исключения
`void printStackTrace()`	Выводит трассировку стека исключений
`void printStackTrace(PrintStream stream)`	Выводит трассировку стека исключений в указанный поток
`void printStackTrace(PrintWriter stream)`	Направляет трассировку стека исключений в указанный поток
`String toString()`	Возвращает объект типа String, содержащий полное описание исключения. Этот метод вызывается из метода println() при выводе объекта типа Throwable

Среди методов, определенных в классе Throwable, наибольший интерес представляют методы pr intStackTrace() и toString(). С помощью метода printStackTrace() можно вывести стандартное сообщение об ошибке и запись последовательности вызовов методов, которые привели к возникновению исключения, А метод toString() позволяет получить стандартное сообщение об ошибке. Этот метод также вызывается в том случае, когда объект исключения передается в качестве параметра методу println(). Применение этих методов демонстрируется в следующем примере программы:

// Применение методов из класса Throwable.
class ExcTest {
    static void genException()  {
        int nums[] = new int[4];

        System.out.println("Before exception is generated.");

        // сгенерировать исключение в связи с попыткой
        // обращения за границы массива
        nums[7] = 10;
        System.out.println("this won't be displayed");
    }
}

class UseThrowableMethods {
    public static void main(String args[])  {

        try {
            ExcTest.genException() ;
        }
        catch (ArraylndexOutOfBoundsException exc) {
            // перехватить исключение
            System.out.println("Standard message is: ");
            System.out.println(exc) ;
            System.out.println("nStack trace: ");
            exc.printStackTrace();
        }

        System.out.println("After catch statement.");
    }
}

Результат выполнения данной программы выглядит следующим образом:

Before exception is generated.
Standard message is:
java.lang.ArraylndexOutOfBoundsException: 7

Stack trace:
java.lang.ArraylndexOutOfBoundsException: 7
    at ExcTest.genException(UseThrowableMethods.java:10)
    at UseThrowableMethods.main(UseThrowableMethods.java:19)
After catch statement.

Использование ключевого слова finally

Иногда требуется определить кодовый блок, который должен выполняться по завершении блока try/catch. Допустим, в процессе работы программы возникло исключение, требующее ее преждевременного завершения. Но в программе открыт файл или установлено сетевое соединение, а следовательно, файл нужно закрыть, а соединение разорвать. Для выполнения подобных операций нормального завершения программы удобно воспользоваться ключевым словом finally.

Для того чтобы определить код, который должен выполняться по завершении блока try/catch, нужно указать блок finally в конце последовательности операторов try/catch. Ниже приведена общая форма записи блока try/catch вместе с блоком finally.

try {
    // Блок кода, в котором отслеживаются ошибки.
}
catch (тип_исключения_1 объект_исключения) {
    // Обработчик исключения тип_исключения_1
}
catch (тип_исключения_2 объект_исключения) {
    // Обработчик исключения тип_исключения_2
}
//. . .
finally {
// Код блока finally
}

Блок finally выполняется всегда по завершении блока try/catch независимо от того, какое именно условие к этому привело. Следовательно, блок finally получит управление как при нормальной работе программы, так и при возникновении ошибки. Более того, он будет вызван даже в том случае, если в блоке try или в одном из блоков catch будет присутствовать оператор return для немедленного возврата из метода.

Ниже приведен краткий пример программы, демонстрирующий применение блока finally.

// Применение блока finally,
class UseFinally {
    public static void genException(int what) {
        int t;
        int nums[] = new int[2];

        System.out.println("Receiving " + what);
        try {
            switch(what) {
            case 0:
                t = 10 / what; // сгенерировать ошибку деления на нуль
                break;
            case 1:
                nums[4] = 4; // сгенерировать ошибку обращения к массиву
                break;
            case 2:
                return; // возвратиться из блока try
            }
        }
        catch (ArithmeticException exc) {
            // перехватить исключение
            System.out.println("Can1t divide by Zero!");
            return; // возвратиться из блока catch
        }
        catch (ArraylndexOutOfBoundsException exc) {
            // перехватить исключение
            System.out.println("No matching element found.");
        }
        // Этот блок выполняется независимо от того, каким
        // образом завершается блок try/catch.
        finally {
            System.out.println("Leaving try.");
        }
    }
}

class FinallyDemo {
    public static void main(String args[]) {

        for(int i=0; i < 3; i++) {
            UseFinally.genException(i);
            System.out.println() ;
        }
    }
}

В результате выполнения данной программы получается следующий результат:

Receiving О
Can't divide by Zero!
Leaving try.

Receiving 1
No matching element found.
Leaving try.

Receiving 2
Leaving try.

Нетрудно заметить, что блок finally выполняется независимо от того, каким об¬
разом завершается блок try/catch.

Использование ключевого слова throws

Иногда исключения нецелесообразно обрабатывать в том методе, в котором они возникают. В таком случае их следует указывать с помощью ключевого слова throws. Ниже приведена общая форма объявления метода, в котором присутствует ключевое слово throws.

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

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

Возможно, вам покажется странным, что в ряде предыдущих примеров ключевое слово throws не указывалось при генерировании исключений за пределами методов. Дело в том, что исключения, генерируемые подклассом Error или RuntimeException, можно и не указывать в списке оператора throws. Исполняющая система Java по умолчанию предполагает, что метод может их генерировать. А исключения всех остальных типов следует непременно объявить с помощью ключевого слова throws. Если этого не сделать, возникнет ошибка при компиляции.

Пример применения оператора throws уже был представлен ранее в этой книге.
Напомним, что при организации ввода с клавиатуры в метод main() потребовалось
включить следующее выражение:

throws java.io.IOException

Теперь вы знаете, зачем это было нужно. При вводе данных может возникнуть исключение IOException, а на тот момент вы еще не знали, как оно обрабатывается. Поэтому мы и указали, что исключение должно обрабатываться за пределами метода main(). Теперь, ознакомившись с исключениями, вы сможете без труда обработать исключение IOException самостоятельно.

Рассмотрим пример, в котором осуществляется обработка исключения IOException. В методе prompt() отображается сообщение, а затем выполняется ввод символов с клавиатуры. Такой ввод данных может привести к возникновению исключения IOException. Но это исключение не обрабатывается в методе prompt(). Вместо этого в объявлении метода указан оператор throws, т.е. обязанности по обработке данного исключению поручаются вызывающему методу. В данном случае вызывающим является метод main(), в котором и перехватывается исключение.

// Применение ключевого слова throws,
class ThrowsDemo {
    // Обратите внимание на оператор throws в объявлении метода.
    public static char prompt(String str)
        throws java.io.IOException {

        System.out.print(str + ": ");
        return (char) System.in.read() ;
    }

    public static void main(String args[]) {
        char ch;

        try {
            // В методе prompt() может быть сгенерировано исключение,
            // поэтому данный метод следует вызывать в блоке try.
            ch = prompt("Enter a letter");
        }
        catch(java.io.IOException exc) {
            System.out.println("I/O exception occurred.");
            ch = 'X';
        }
        System.out.println("You pressed " + ch);
    }
}

Обратите внимание на одну особенность приведенного выше примера. Класс IOException относится к пакету java. io. Как будет разъяснено в главе 10, в этом пакете содержатся многие языковые средства Java для организации ввода-вывода. Следовательно, пакет java.io можно импортировать, а в программе указать только имя класса IOException.

Новые средства обработки исключений, внедренные в версии JDK 7

С появлением версии JDK 7 механизм обработки исключений в Java был значительно усовершенствован благодаря внедрению трех новых средств. Первое из них поддерживает автоматическое управление ресурсами, позволяющее автоматизировать процесс освобождения таких ресурсов, как файлы, когда они больше не нужны. В основу этого средства положена расширенная форма оператора try, называемая оператором try с ресурсами и описываемая в главе 10 при рассмотрении файлов. Второе новое средство называется многократным перехватом, а третье — окончательным или более точным повторным генерированием исключений. Два последних средства рассматриваются ниже.

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

Для организации многократного перехвата следует указать список исключений в одном операторе catch, разделив их типы оператором поразрядного ИЛИ. Каждый параметр многократного перехвата неявно указывается как final. (По желанию модификатор доступа final можно указать и явным образом, но это совсем не обязательно.) А поскольку каждый параметр многократного перехвата неявно указывается как final, то ему нельзя присвоить новое значение.

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

catch(final ArithmeticException | ArraylndexOutOfBoundsException e) {

Ниже приведен краткий пример программы, демонстрирующий применение многократного перехвата исключений.

// Применение средства многократного перехвата исключений.
// Примечание: для компиляции этого кода требуется JDK 7
// или более поздняя версия данного комплекта,
class MultiCatch {
    public static void main(String args[]) {
        int a=88, b=0;
        int result;
        char chrs[] = { 'А', 'В', 'C' };

        for(int i=0; i < 2; i++)    {
            try {
                if (i == 0)
                    // сгенерировать исключение ArithmeticException
                    result = а / b;
                else
                    // сгенерировать исключение ArraylndexOutOfBoundsException
                    chrs[5] = 'X';
            }
            // В этом операторе catch организуется перехват обоих исключений,
            catch(ArithmeticException | ArraylndexOutOfBoundsException е) {
                System.out.println("Exception caught: " + e);
            }
        }

        System.out.println("After multi-catch.");
    }
}

В данном примере программы исключение ArithmeticException генерируется при попытке деления на нуль, а исключение ArraylndexOutOfBoundsException — при попытке обращения за границы массива chrs. Оба исключения перехватываются одним оператором catch.

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

Встроенные в Java исключения

В стандартном пакете java. lang определены некоторые классы, представляющие стандартные исключения Java. Часть из них использовалась в предыдущих примерах программ. Наиболее часто встречаются исключения из подклассов стандартного класса RuntimeException. А поскольку пакет java. lang импортируется по умолчанию во все программы на Java, то исключения, производные от класса RuntimeException, становятся доступными автоматически. Их даже обязательно включать в список оператора throws. В терминологии языка Java такие исключения называют непроверяемыми, поскольку компилятор не проверяет, обрабатываются или генерируются подобные исключения в методе. Непроверяемые исключения, определенные в пакете java.lang, приведены в табл. 9.2, тогда как в табл. 9.3 — те исключения из пакета j ava. lang, которые следует непременно включать в список оператора throws при объявлении метода, если, конечно, в методе содержатся операторы, способные генерировать эти исключения, а их обработка не предусмотрена в теле метода. Такие исключения принято называть проверяемыми. В Java предусмотрен также ряд других исключений, определения которых содержатся в различных библиотеках классов. К их числу можно отнести упоминавшееся ранее исключение IOException.

Таблица 9.2. Непроверяемые исключения, определенные в пакете java.lang

Исключение	Описание
ArithmeticException	Арифметическая ошибка, например попытка деления на нуль
ArraylndexOutOfBoundsException	Попытка обращения за границы массива
ArrayStoreException	Попытка ввести в массив элемент, несовместимый с ним по типу
ClassCastException	Недопустимое приведение типов
EnumConstNotPresentException	Попытка использования нумерованного значения, которое не было определено ранее
IllegalArgumentException	Недопустимый параметр при вызове метода
IllegalMonitorStateException	Недопустимая операция контроля, например, ожидание разблокировки потока
IllegalStateException	Недопустимое состояние среды выполнения или приложения
IllegalThreadStateException	Запрашиваемая операция несовместима с текущим состоянием потока
IndexOutOfBoundsException	Недопустимое значение индекса
NegativeArraySizeException	Создание массива отрицательного размера
NullPointerException	Недопустимое использование пустой ссылки
NumberFormatException	Неверное преобразование символьной строки в число
SecurityException	Попытка нарушить систему защиты
StringlndexOutOfBounds	Попытка обращения к символьной строке за ее границами
TypeNotPresentException	Неизвестный тип
UnsupportedOperationException	Неподдерживаемая операция

Таблица 9.3. Проверяемые исключения, определенные в пакете java.lang

Исключение	Описание
ClassNotFoundException	Класс не найден
CloneNotSupportedException	Попытка клонирования объекта, не реализующего интерфейс Cloneable
IllegalAccessException	Доступ к классу запрещен
InstantiationException	Попытка создания объекта абстрактного класса или интер¬фейса
InterruptedException	Прерывание одного потока другим
NoSuchFieldException	Требуемое поле не существует
NoSuchMethodException	Требуемый метод не существует
ReflectiveOperationException	Суперкласс исключений, связанных с рефлексией (добавлен в версии JDK 7)

Создание подклассов, производных от класса Exception

Несмотря на то что встроенные в Java исключения позволяют обрабатывать большинство ошибок, механизм обработки исключений не ограничивается только этими ошибками. В частности, можно создавать исключения для обработки потенциальных ошибок в прикладной программе. Создать исключение несложно. Для этого достаточно определить подкласс, производный от класса Exception, который, в свою очередь, является подклассом, порожденным классом Throwable. В создаваемый подкласс не обязательно включать реализацию каких-то методов. Сам факт существования такого подкласса позволяет использовать его в качестве исключения.

В классе Exception не определены новые методы. Он лишь наследует методы, предоставляемые классом Throwable. Таким образом, все исключения, включая и создаваемые вами, содержат методы класса Throwable. Конечно же, вы вольны переопределить в создаваемом вами классе один или несколько методов.

Ниже приведен пример, в котором создается исключение NonlntResultException. Оно генерируется в том случае, если результатом деления двух целых чисел является дробное число. В классе NonlntResultException содержатся два поля, предназначенные для хранения целых чисел, а также конструктор. В нем также переопределен метод toString(), что дает возможность выводить описание исключения с помощью метода println().

// Применение специально создаваемого исключения.
// создать исключение
class NonlntResultException extends Exception {
    int n;
    int d;

    NonlntResultException(int i, int j) {
        n = i;
        d = j;
    }

    public String toString()    {
        return "Result of " + n + " / " + d +
                " is non-integer.";
    }
}

class CustomExceptDemo {
    public static void main(String args[]) {

        // В массиве numer содержатся нечетные числа,
        int numer[] = { 4, 8, 15, 32, 64, 127, 256, 512 };
        int denom[] = { 2, 0, 4, 4, 0, 8 };

        for(int i=0; i<numer.length; i++)   {
            try {
                if((numer[i]%2) != 0)
                    throw new
                        NonlntResultException(numer[i], denom[i]);
                System.out.println(numer[i] + " / " +
                                   denom[i] + 11 is " +
                                   numer[i]/denom[i]);
            }
            catch (ArithmeticException exc) {
                // перехватить исключение
                System.out.println("Can11 divide by Zero!");
            }
            catch (ArraylndexOutOfBoundsException exc) {
                // перехватить исключение
                System.out.println("No matching element found.");
            }
            catch (NonlntResultException exc) {
                System.out.println(exc) ;
            }
        }
    }
}

Результат выполнения данной программы выглядит следующим образом:

4 / 2 is 2
Can't divide by Zero!
Result of 15 / 4 is non-integer.
32 / 4 is 8
Can't divide by Zero!
Result of 127 / 8 is non-integer.
No matching element found.
No matching element found.

Пример для опробования 9.1.
Добавление исключений в класс очереди

В этом проекте предстоит создать два класса исключении, которые будут использоваться классом очереди, разработанным в примере для опробования 8.1. Эти исключения должны указывать на переполнение и опустошение очереди, а генерировать их будут методы put() и get() соответственно. Ради простоты эти исключения добавляются в класс FixedQueue, но вы можете без труда внедрить их в любые другие классы очереди, разработанные в примере для опробования 8.1.

Последовательность действий

Создайте файл QExcDemo.java.

Определите следующие исключения в файле QExcDemo.java:

/*
Пример для опробования 9.1.
Добавление обработчиков исключений в класс очереди.
*/
// Исключение, указывающее на переполнение очереди,
class QueueFullException extends Exception {
    int size;

    QueueFullException(int s) { size = s; }

    public String toString()    {
        return "nQueue is full. Maximum size is " + size;
    }
}

// Исключение, указывающее на опустошение очереди,
class QueueEmptyException extends Exception {
    public String toString()    {
        return "nQueue is empty.";
    }
}

Исключение QueueFullException генерируется при попытке поместить элемент в уже заполненную очередь, а исключение QueueEmptyException — в ответ на попытку извлечь элемент из пустой очереди.

Измените класс FixedQueue таким образом, чтобы при возникновении ошибки он генерировал исключение. Соответствующий код приведен ниже. Введите этот код в файл QExcDemo.java.
```
// Класс, реализующий очередь фиксированного размера
// для хранения символов.
class FixedQueue implements ICharQ {
    private char q[]; // Массив для хранения элементов очереди,
    private int putloc, getloc; // Индексы размещения и извлечения

    // элементов очереди.
    // создать пустую очередь заданного размера
    public FixedQueue(int size) {
        q = new char[size+1]; // выделить память для очереди
        putloc = getloc = 0;
    }

    // поместить символ в очередь
    public void put(char ch)
    throws QueueFullException {

        if(putloc==q.length-1)
            throw new QueueFullException(q.length-1);

        putloc++;
        q[putloc] = ch;
    }

    // извлечь символ из очереди
    public char get()
    throws QueueEmptyException {

        if(getloc == putloc)
            throw new QueueEmptyException();

        getloc++;
        return q[getloc];
    }
}
```
Добавление исключений в класс FixedQueue выполняется в два этапа. Сначала в определении методов get() и put() указывается оператор throws с типом генерируемого исключения. А затем в этих методах организуется генерирование исключений при возникновении ошибок. Используя исключения, можно организовать обработку ошибок в вызывающей части программы наиболее рациональным способом. Как вы помните, в предыдущих версиях рассматриваемой здесь программы выводились только сообщения об ошибках. А генерирование исключений является более профессиональным подходом к разработке данной программы.

Для опробования усовершенствованного класса FixedQueue введите в файл QExcDemo.java приведенный ниже исходный код класса QExcDemo.

// Демонстрация исключений при обращении с очередью,
class QExcDemo {
    public static void main(String args[])  {
        FixedQueue q = new FixedQueue(10);
        char ch;
        int i;

        try {
            // Переполнение очереди.
            for(i=0; i < 11; i++)   {
                System.out.print("Attempting to store : " +
                                 (char) ('A' + i));
                q.put((char) (fA' + i));
                System.out.println(" - OK");
            }
            System.out.println();
        }
        catch (QueueFullException exc) {
            System.out.println(exc);
        }
        System.out.println();

        try {
            // Попытка извлечь символ из пустой очереди.
            for(i=0; i < 11; i++) {
            System.out.print("Getting next char: ");
            ch = q.get();
            System.out.println(ch);
            }
        }
        catch (QueueEmptyException exc) {
            System.out.println(exc);
        }
    }
}

Класс FixedQueue реализует интерфейс ICharQ, в котором определены методы get() и put(), и поэтому интерфейс ICharQ необходимо изменить таким образом, чтобы в нем отражалось наличие операторов throws. Ниже приведен видоизмененный соответственно код интерфейса ICharQ. Не забывайте о том, что он должен храниться в файле ICharQjava.
```
// Интерфейс очереди для хранения символов с генерированием исключений,
public interface ICharQ {
    // поместить символ в очередь
    void put(char ch) throws QueueFullException;
    // извлечь символ из очереди
    char get() throws QueueEmptyException;
}
```

Скомпилируйте сначала новую версию исходного файла IQChar. j ava, а затем исходный файл QExcDemo. java и запустите программу QExcDemo на выполнение. В итоге вы получите следующий результат ее выполнения:

Attempting to store A - OK
Attempting to store В - OK
Attempting to store С - OK
Attempting to store D - OK
Attempting to store E - OK
Attempting to store F - OK
Attempting to store G - OK
Attempting to store H - OK
Attempting to store I - OK
Attempting to store J - OK
Attempting to store К
Queue is full. Maximum size is 10

Getting next char: A
Getting next char: В
Getting next char: С
Getting next char: D
Getting next char: E
Getting next char: F
Getting next char: G
Getting next char: H
Getting next char: I
Getting next char: J
Getting next char:
Queue is empty.

Упражнение для самопроверки по материалу главы 9

Какой класс находится на вершине иерархии исключений?
Объясните вкратце, как пользоваться ключевыми словами try и catch?

Какая ошибка допущена в приведенном ниже фрагменте кода?

// ...
vals[18] = 10;
catch (ArraylndexOutOfBoundsException exc) {
    // обработать ошибку
}

Что произойдет, если исключение не будет перехвачено?

Какая ошибка допущена в приведенном ниже фрагменте кода?

class A extends Exception { ...
class В extends А { ...
    // ...
try {
    // ...
}
catch (A exc) { ... }
catch (В exc) { ... }

Может ли внутренний блок catch повторно генерировать исключение, которое будет обработано во внешнем блоке catch?
Блок finally — последний фрагмент кода, выполняемый перед завершением программы. Верно или неверно? Обоснуйте свой ответ.
Исключения какого типа необходимо явно объявлять с помощью оператора throws, включаемого в объявление метода?
Какая ошибка допущена в приведенном ниже фрагменте кода?
```
class MyClass { // ... }
// ...
throw new MyClass();
```
Отвечая на вопрос 3 упражнения для самопроверки по материалу главы 6, вы создали класс Stack. Добавьте в него специальные исключения для реагирования на попытку поместить элемент в переполненный стек и извлечь элемент из пустого стека.
Какими тремя способами можно сгенерировать исключение?
Назовите два подкласса, производных непосредственно от класса Throwable.
Что такое многократный перехват?
Следует ли перехватывать в программе исключения типа Error?

Источник

Содержание

Исключения
Несколько исключений
Вложенные операторы try
Оператор throw
Оператор throws
Оператор finally
Встроенные исключения Java
Создание собственных классов исключений
Перехват произвольных исключений
Основные правила обработки исключений

Исключения

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

В методе, в котором происходит ошибка, создаётся и передаётся специальный объект. Метод может либо обработать исключение самостоятельно, либо пропустить его. В любом случае исключение ловится и обрабатывается. Исключение может появиться благодаря самой системе, либо вы сами можете создать его вручную. Системные исключения возникают при неправильном использовании языка Java или запрещённых приёмов доступа к системе. Ваши собственные исключения обрабатывают специфические ошибки вашей программы.

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

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

Операторы программы, которые вы хотите отслеживать, помещаются в блок try. Если исключение произошло, то оно создаётся и передаётся дальше. Ваш код может перехватить исключение при помощи блока catch и обработать его. Системные исключения автоматически передаются самой системой. Чтобы передать исключение вручную, используется throw. Любое исключение, созданное и передаваемое внутри метода, должно быть указано в его интерфейсе ключевым словом throws. Любой код, который следует выполнить обязательно после завершения блока try, помещается в блок finally

Схематически код выглядит так:

Существует специальный класс для исключений Trowable. В него входят два класса Exception и Error.

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

Класс Error служит для обработки ошибок в самом языке Java и на практике вам не придётся иметь с ним дело.

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

Я поместил код в обработчик щелчка кнопки. Когда система времени выполнения Java обнаруживает попытку деления на ноль, она создаёт объект исключения и передаёт его. Да вот незадача, никто не перехватывает его, хотя это должны были сделать вы. Видя вашу бездеятельность, объект перехватывает стандартный системный обработчик Java, который отличается вредных характером. Он останавливает вашу программу и выводит сообщение об ошибке, которое можно увидеть в журнале LogCat:

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

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

Поместим проблемный код в блок try, а в блоке catch обработаем исключение.

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

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

Операторы try и catch работают совместно в паре. Хотя возможны ситуации, когда catch может обрабатывать несколько вложенных операторов try.

Если вы хотите увидеть описание ошибки, то параметр e и поможет увидеть ёго.

По умолчанию, класс Trowable, к которому относится ArithmeticException возвращает строку, содержащую описание исключения. Но вы можете и явно указать метод e.toString.

Несколько исключений

Фрагмент кода может содержать несколько проблемных мест. Например, кроме деления на ноль, возможна ошибка индексации массива. В таком случае вам нужно создать два или более операторов catch для каждого типа исключения. Причём они проверяются по порядку. Если исключение будет обнаружено у первого блока обработки, то он будет выполнен, а остальные проверки пропускаются и выполнение программы продолжается с места, который следует за блоком try/catch.

В примере мы добавили массив с тремя элементами, но обращаемся к четвёртому элементу, так как забыли, что отсчёт у массива начинается с нуля. Если оставить значение переменной zero равным нулю, то сработает обработка первого исключения деления на ноль, и мы даже не узнаем о существовании второй ошибки. Но допустим, что в результате каких-то вычислений значение переменной стало равно единице. Тогда наше исключение ArithmeticException не сработает. Но сработает новое добавленное исключение ArrayIndexOutOfBoundsException. А дальше всё пойдёт как раньше.

Тут всегда нужно помнить одну особенность. При использовании множественных операторов catch обработчики подклассов исключений должные находиться выше, чем обработчики их суперклассов. Иначе, суперкласс будет перехватывать все исключения, имея большую область перехвата. Иными словами, Exception не должен находиться выше ArithmeticException и ArrayIndexOutOfBoundsException. К счастью, среда разработки сама замечает непорядок и предупреждает вас, что такой порядок не годится. Увидев такую ошибку, попробуйте перенести блок обработки исключений ниже.

Вложенные операторы try

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

Оператор throw

Часть исключений может обрабатывать сама система. Но можно создать собственные исключения при помощи оператора throw. Код выглядит так:

Вам нужно создать экземпляр класса Throwable или его наследников. Получить объект класса Throwable можно в операторе catch или стандартным способом через оператор new.

Мы могли бы написать такой код для кнопки:

Мы объявили объект класса Cat, но забыли его проинициализировать, например, в onCreate(). Теперь нажатие кнопки вызовет исключение, которое обработает система, а в логах мы можем прочитать сообщение об ошибке. Возможно, вы захотите использовать другое исключение, например, throw new UnsupportedOperationException(«Котик не инициализирован»);.

В любом случае мы передали обработку ошибки системе. В реальном приложении вам нужно обработать ошибку самостоятельно.

Поток выполнения останавливается непосредственно после оператора throw и другие операторы не выполняются. При этом ищется ближайший блок try/catch соответствующего исключению типа.

Перепишем пример с обработкой ошибки.

Мы создали новый объект класса NullPointerException. Многие классы исключений кроме стандартного конструктора по умолчанию с пустыми скобками имеют второй конструктор с строковым параметром, в котором можно разместить подходящую информацию об исключении. Получить текст из него можно через метод getMessage(), что мы и сделали в блоке catch.

Теперь программа не закроется аварийно, а будет просто выводить сообщения в всплывающих Toast.

Оператор throws

Если метод может породить исключение, которое он сам не обрабатывает, он должен задать это поведение так, чтобы вызывающий его код мог позаботиться об этом исключении. Для этого к объявлению метода добавляется конструкция throws, которая перечисляет типы исключений (кроме исключений Error и RuntimeException и их подклассов).

Общая форма объявления метода с оператором throws:

В фрагменте список_исключений можно указать список исключений через запятую.

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

Если вы запустите пример, то получите ошибку. Исправим код.

Мы поместили вызов метода в блок try и вызвали блок catch с нужным типом исключения. Теперь ошибки не будет.

Оператор finally

Когда исключение передано, выполнение метода направляется по нелинейному пути. Это может стать источником проблем. Например, при входе метод открывает файл и закрывает при выходе. Чтобы закрытие файла не было пропущено из-за обработки исключения, был предложен механизм finally.

Ключевое слово finally создаёт блок кода, который будет выполнен после завершения блока try/catch, но перед кодом, следующим за ним. Блок будет выполнен, независимо от того, передано исключение или нет. Оператор finally не обязателен, однако каждый оператор try требует наличия либо catch, либо finally.

Встроенные исключения Java

Существуют несколько готовых системных исключений. Большинство из них являются подклассами типа RuntimeException и их не нужно включать в список throws. Вот небольшой список непроверяемых исключений.

ArithmeticException — арифметическая ошибка, например, деление на нуль
ArrayIndexOutOfBoundsException — выход индекса за границу массива
ArrayStoreException — присваивание элементу массива объекта несовместимого типа
ClassCastException — неверное приведение
EnumConstantNotPresentException — попытка использования неопределённого значения перечисления
IllegalArgumentException — неверный аргумент при вызове метода
IllegalMonitorStateException — неверная операция мониторинга
IllegalStateException — некорректное состояние приложения
IllegalThreadStateException — запрашиваемая операция несовместима с текущим потоком
IndexOutofBoundsException — тип индекса вышел за допустимые пределы
NegativeArraySizeException — создан массив отрицательного размера
NullPointerException — неверное использование пустой ссылки
NumberFormatException — неверное преобразование строки в числовой формат
SecurityException — попытка нарушения безопасности
StringIndexOutOfBounds — попытка использования индекса за пределами строки
TypeNotPresentException — тип не найден
UnsupportedOperationException — обнаружена неподдерживаемая операция

Список проверяемых системных исключений, которые можно включать в список throws.

ClassNotFoundException — класс не найден
CloneNotSupportedException — попытка клонировать объект, который не реализует интерфейс Cloneable
IllegalAccessException — запрещен доступ к классу
InstantiationException — попытка создать объект абстрактного класса или интерфейса
InterruptedException — поток прерван другим потоком
NoSuchFieldException — запрашиваемое поле не существует
NoSuchMethodException — запрашиваемый метод не существует
ReflectiveOperationException — исключение, связанное с рефлексией

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

Система не может предусмотреть все исключения, иногда вам придётся создать собственный тип исключения для вашего приложения. Вам нужно наследоваться от Exception (напомню, что этот класс наследуется от Trowable) и переопределить нужные методы класса Throwable. Либо вы можете наследоваться от уже существующего типа, который наиболее близок по логике с вашим исключением.

final void addSuppressed(Throwable exception) — добавляет исключение в список подавляемых исключений (JDK 7)
Throwable fillInStackTrace() — возвращает объект класса Throwable, содержащий полную трассировку стека.
Throwable getCause() — возвращает исключение, лежащее под текущим исключение или null
String getLocalizedMessage() — возвращает локализованное описание исключения
String getMessage() — возвращает описание исключения
StackTraceElement[] getStackTrace() — возвращает массив, содержащий трассировку стека и состояний из элементов класса StackTraceElement
final Throwable[] getSuppressed() — получает подавленные исключения (JDK 7)
Throwable initCause(Throwable exception) — ассоциирует исключение с вызывающим исключением. Возвращает ссылку на исключение.
void printStackTrace() — отображает трассировку стека
void printStackTrace(PrintStream stream) — посылает трассировку стека в заданный поток
void printStackTrace(PrintWriter stream) — посылает трассировку стека в заданный поток
void setStackTrace(StackTraceElement elements[]) — устанавливает трассировку стека для элементов (для специализированных приложений)
String toString() — возвращает объект класса String, содержащий описание исключения.

Самый простой способ — создать класс с конструктором по умолчанию.

Мы создали собственный класс HungryCatException, в методе testMethod() его возбуждаем, а по нажатию кнопки вызываем этот метод. В результате наше исключение сработает.

Создать класс исключения с конструктором, который получает аргумент-строку, также просто.

Ещё вариант. Добавим также метод toString().

Теперь класс содержит два конструктора. Во втором конструкторе используется конструктор родительского класса с аргументом String, вызываемый ключевым словом super.

Перехват произвольных исключений

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

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

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

Используйте исключения для того, чтобы:

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

Источник

Исключения

try
Оператор throw
Оператор throws
Оператор finally
Встроенные исключения Java
Создание собственных классов исключений

Схематически код выглядит так:


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

Существует специальный класс для исключений Trowable. В него входят два класса Exception и Error.

Класс Error служит для обработки ошибок в самом языке Java и на практике вам не придётся иметь с ним дело.


int catNumber;
int zero;
catNumber = 1; // у меня один кот
zero = 0; // ноль, он и в Африке ноль
int result = catNumber / zero;

Caused by: java.lang.ArithmeticException: divide by zero at ru.alexanderklimov.test.MainActivity.onClick(MainActivity.java:79)

Поместим проблемный код в блок try, а в блоке catch обработаем исключение.


int catNumber;
int zero;

try { // мониторим код
    catNumber = 1; // у меня один кот
    zero = 0; // ноль, он и в Африке ноль
    int result = catNumber / zero;
    Toast.makeText(this, "Не увидите это сообщение!", Toast.LENGTH_LONG).show();
} catch (ArithmeticException e) {
    Toast.makeText(this, "Нельзя котов делить на ноль!", Toast.LENGTH_LONG).show();
}
Toast.makeText(this, "Жизнь продолжается", Toast.LENGTH_LONG).show();

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

Если вы хотите увидеть описание ошибки, то параметр e и поможет увидеть ёго.


catch (ArithmeticException e) {
	Toast.makeText(this, e + ": Нельзя котов делить на ноль!", Toast.LENGTH_LONG).show();
}

Несколько исключений


int catNumber;
int zero;

try { // мониторим код
    catNumber = 1; // у меня один кот
    zero = 1; // ноль, он и в Африке ноль
    int result = catNumber / zero;
    // Создадим массив из трёх котов
    String[] catNames = {"Васька", "Барсик", "Мурзик"};
    catNames[3] = "Рыжик";
    Toast.makeText(this, "Не увидите это сообщение!", Toast.LENGTH_LONG).show();
} catch (ArithmeticException e) {
    Toast.makeText(this, e.toString() + ": Нельзя котов делить на ноль!", Toast.LENGTH_LONG).show();
}
catch (ArrayIndexOutOfBoundsException e) {
	Toast.makeText(this, "Ошибка: " + e.toString(), Toast.LENGTH_LONG).show();
}
Toast.makeText(this, "Жизнь продолжается", Toast.LENGTH_LONG).show();

Вложенные операторы try

Оператор throw


throw экземпляр_Throwable

Мы могли бы написать такой код для кнопки:


Cat cat;

public void onClick(View view) {
    if(cat == null){
        throw new NullPointerException("Котик не инициализирован");
    }
}

Перепишем пример с обработкой ошибки.


public void onClick(View view) {
    if (cat == null) {
        try {
            throw new NullPointerException("Кота не существует");
        } catch (NullPointerException e) {
            Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show();
        }
    }
}

Теперь программа не закроется аварийно, а будет просто выводить сообщения в всплывающих Toast.

Оператор throws

Общая форма объявления метода с оператором throws:


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

В фрагменте список_исключений можно указать список исключений через запятую.

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


// Метод без обработки исключения
public void createCat(){
	Toast.makeText(this, "Вы создали котёнка", Toast.LENGTH_LONG).show();
	throw new NullPointerException("Кота не существует");
}

// Щелчок кнопки
public void onClick(View v) {
	createCat();
}

Если вы запустите пример, то получите ошибку. Исправим код.


// Без изменений
public void createCat() throws NullPointerException {
	Toast.makeText(this, "Вы создали котёнка", Toast.LENGTH_LONG).show();
	throw new NullPointerException("Кота не существует");
}

// Щелчок кнопки
public void onClick(View v) {
	try {
		createCat();
	} catch (NullPointerException e) {
		// TODO: handle exception
		Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show();
	}
}

Мы поместили вызов метода в блок try и вызвали блок catch с нужным типом исключения. Теперь ошибки не будет.

Оператор finally

ArithmeticException — арифметическая ошибка, например, деление на нуль
ArrayIndexOutOfBoundsException — выход индекса за границу массива
ArrayStoreException — присваивание элементу массива объекта несовместимого типа
ClassCastException — неверное приведение
EnumConstantNotPresentException — попытка использования неопределённого значения перечисления
IllegalArgumentException — неверный аргумент при вызове метода
IllegalMonitorStateException — неверная операция мониторинга
IllegalStateException — некорректное состояние приложения
IllegalThreadStateException — запрашиваемая операция несовместима с текущим потоком
IndexOutofBoundsException — тип индекса вышел за допустимые пределы
NegativeArraySizeException — создан массив отрицательного размера
NullPointerException — неверное использование пустой ссылки
NumberFormatException — неверное преобразование строки в числовой формат
SecurityException — попытка нарушения безопасности
StringIndexOutOfBounds — попытка использования индекса за пределами строки
TypeNotPresentException — тип не найден
UnsupportedOperationException — обнаружена неподдерживаемая операция

Список проверяемых системных исключений, которые можно включать в список throws.

ClassNotFoundException — класс не найден
CloneNotSupportedException — попытка клонировать объект, который не реализует интерфейс Cloneable
IllegalAccessException — запрещен доступ к классу
InstantiationException — попытка создать объект абстрактного класса или интерфейса
InterruptedException — поток прерван другим потоком
NoSuchFieldException — запрашиваемое поле не существует
NoSuchMethodException — запрашиваемый метод не существует
ReflectiveOperationException — исключение, связанное с рефлексией

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

final void addSuppressed(Throwable exception) — добавляет исключение в список подавляемых исключений (JDK 7)
Throwable fillInStackTrace() — возвращает объект класса Throwable, содержащий полную трассировку стека.
Throwable getCause() — возвращает исключение, лежащее под текущим исключение или null
String getLocalizedMessage() — возвращает локализованное описание исключения
String getMessage() — возвращает описание исключения
StackTraceElement[] getStackTrace() — возвращает массив, содержащий трассировку стека и состояний из элементов класса StackTraceElement
final Throwable[] getSuppressed() — получает подавленные исключения (JDK 7)
Throwable initCause(Throwable exception) — ассоциирует исключение с вызывающим исключением. Возвращает ссылку на исключение.
void printStackTrace() — отображает трассировку стека
void printStackTrace(PrintStream stream) — посылает трассировку стека в заданный поток
void printStackTrace(PrintWriter stream) — посылает трассировку стека в заданный поток
void setStackTrace(StackTraceElement elements[]) — устанавливает трассировку стека для элементов (для специализированных приложений)
String toString() — возвращает объект класса String, содержащий описание исключения.

Самый простой способ — создать класс с конструктором по умолчанию.


// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.

package ru.alexanderklimov.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 HungryCatException{
        System.out.println("Возбуждаем HungryCatException из метода testMethod()");
        throw new HungryCatException(); // конструктор по умолчанию
    }

    public void onClick(View view) {
        try {
            testMethod();
        } catch (HungryCatException e) {
            e.printStackTrace();
            System.out.println("Наше исключение перехвачено");
        }
    }

    class HungryCatException extends Exception{
    }
}

Создать класс исключения с конструктором, который получает аргумент-строку, также просто.


// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.

package ru.alexanderklimov.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 HungryCatException {
        System.out.println("Возбуждаем HungryCatException из метода testMethod()");
        throw new HungryCatException(); // конструктор по умолчанию
    }

    public void testMethod2() throws HungryCatException {
        System.out.println("Возбуждаем HungryCatException из метода testMethod2()");
        throw new HungryCatException("Создано во втором методе");
    }

    public void onClick(View view) {
        try {
            testMethod();
        } catch (HungryCatException e) {
            e.printStackTrace();
            System.out.println("Наше исключение перехвачено");
        }

        try {
            testMethod2();
        } catch (HungryCatException e) {
            e.printStackTrace();
        }
    }

    class HungryCatException extends Exception {
        HungryCatException() {
        }

        HungryCatException(String msg) {
            super(msg);
        }
    }
}

Ещё вариант. Добавим также метод toString().


class CustomException extends Exception {
    String message;

    CustomException(String str) {
        message = str;
    }

    public String toString() {
        return ("Custom Exception Occurred: " + message);
    }
}

// где-то вызываем
try {
    throw new CustomException("This is a custom message");
} catch (CustomException e) {
    System.out.println(e);
}

Перехват произвольных исключений

cacth(Exception e) {
    Log.w("Log", "Перехвачено исключение");
}

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

Используйте исключения для того, чтобы:

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

что такое исключения (Exceptions);
как они возникают и чем отличаются от ошибок (Errors);
зачем нужна конструкция try-catch;
как разобраться в полученном исключении
и как вызвать исключение самому.

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

За примером далеко ходить не надо: сделаем то, что нам запрещали ещё в школе, — поделим на ноль.


public static void main(String[] args) {
    hereWillBeTrouble(42, 0);
}

public static void hereWillBeTrouble(int a, int b) {
    int oops = a / b;
    System.out.println(oops);
}

А получим вот что:

Это и есть исключение.

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

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

У всех классов исключений есть общий класс-предок Throwable, от него наследуются классы Error и Exception, базовые для всех прочих.

Верхушка иерархии исключений Java

Error — это критические условия, в которых работа программы должна быть завершена. Например, когда при выполнении программы закончилась память, произошёл сбой в системе или виртуальной машине. Не будем задерживаться на этой ветке, поскольку документация Java говорит:

Error is the superclass of all the exceptions from which ordinary programs are not ordinarily expected to recover.

Что в переводе означает: ошибки (Error) — это такие исключительные ситуации, в которых восстанавливать работу программы не предполагается.

То есть это проблемы, которые нельзя (недопустимо) исправлять на ходу. Всё, что нам остаётся, — извиниться перед пользователем и впредь писать программы, где возникнет меньше подобных ситуаций. Например, не допускать такой глубокой рекурсии, как в коде ниже:


static void notGood() {
    System.out.println("Только не снова!");
    notGood();
}

При работе этого метода у нас возникнет ошибка: Exception in thread «main» java.lang.StackOverflowError — стек вызовов переполнился, так как мы не указали условие выхода из рекурсии.

А теперь об Exception. Эти исключительные ситуации возникают, если разработчик допустил невыполнимую операцию, не предусмотрел особые случаи в бизнес-логике программы (или сообщает о них с помощью исключений).

1. Невыполнимая операция

Мир не рухнул, как в случае с Error, просто Java не знает, что делать дальше. Как раз из этого разряда деление на ноль в начале статьи: и правда, какое значение тогда присвоить переменной oops?

Убедитесь сами, что исключение класса ArithmeticException наследуется как раз от Exception.

Стоит запомнить. В IntelliJ IDEA, чтобы увидеть положение класса в иерархии, выберите его и нажмите Ctrl + H (или на пункт Type Hierarchy в меню Navigate).

Другая частая ситуация — обращение к несуществующему элементу массива. Например, у нас в нём десять элементов, а мы пытаемся обратиться к одиннадцатому.

2. Особый случай в бизнес-логике программы

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

Или пользователь вводит дату начала некоторого периода и дату его окончания. Вторая дата не может быть раньше первой.

Или, допустим, у нас есть метод, который читает файл. Сам метод написан верно. Пользователь передал в него корректный путь. Только вот у этого работника нет права читать этот файл (его роль и права обусловлены предметной областью). Что же тогда методу возвращать? Вернуть-то нечего, ведь метод не отработал. Самое очевидное решение — выдать исключение.

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

Простейший вариант — ничего; возникает исключение — программа просто прекращает работать.

Чтобы убедиться в этом, выполним код:


public static void main(String[] args) {
    hereWillBeTrouble(42, 0);
}

public static void hereWillBeTrouble(int a, int b) {
    System.out.println("Всё, что было до...");
    int oops = a / b;
    System.out.println(oops);
    System.out.println("Всё, что будет после...");
}

Так и есть: до деления на ноль код выполнялся, а после — нет.

Это интересно: когда возникает исключение, программисты выдают что-то вроде «код [вы]бросил исключение» или «код кинул исключение». А глагол таков потому, что все исключения — наследники класса Throwable, что значит «бросаемый» / «который можно бросить».

Второе, что можно делать с исключениями, — это их обрабатывать.

Для этого нужно заключить кусок кода, который может вызвать исключение, в конструкцию try-catch.

Как это работает: если в блоке try возникает исключение, которое указано в блоке catch, то исполнение блока try прервётся и выполнится код из блока catch.

Например:


public static void main(String[] args) {
    hereWillBeTrouble();
}

private static void hereWillBeTrouble(int a, int b) {
    int oops;
    try {
        System.out.println("Всё, что было до...");
        oops = a / b;
        System.out.println(oops);
        System.out.println("Всё, что будет после...");
    } catch (ArithmeticException e) {
        System.out.println("Говорили же не делить на ноль!");
        oops = 0;
    }
    System.out.println("Метод отработал");
}

Разберём этот код.

Если блок try кинет исключение ArithmeticException, то управление перехватит блок catch, который выведет строку «Говорили же не делить на ноль!», а значение oops станет равным 0.

После этого программа продолжит работать как ни в чём не бывало: выполнится код после блока try-catch, который сообщит: «Метод отработал».

Проверьте сами: запустите код выше. Вызовите метод hereWillBeTrouble с любыми значениями аргументов кроме нулевого b. Если в блоке try не возникнет исключений, то его код выполнится целиком, а в блок catch мы даже не попадём.

Есть ещё и третий вариант — пробросить исключение наверх. Но об этом в следующей статье.

Вернёмся к первой картинке. Посмотрим, что нам сказала Java, когда произошло исключение:

Начинаем разбирать сверху вниз:

— это указание на поток, в котором произошло исключение. В нашей простой однопоточной программе это поток main.

— какое исключение брошено. У нас это ArithmeticException. А java.lang.ArithmeticException — полное название класса вместе с пакетом, в котором он размещается.

— весточка, которую принесло исключение. Дело в том, что одно и то же исключение нередко возникает по разным причинам. И тут мы видим стандартное пояснение «/ by zero» — из-за деления на ноль.

— это самое интересное: стектрейс.

Стектрейс (Stack trace) — это упорядоченный список методов, сквозь которые исключение пронырнуло.

У нас оно возникло в методе hereWillBeTrouble на 8-й строке в классе Main (номер строки и класс указаны в скобках синим). А этот метод, в свою очередь, вызван методом main на 3-й строке класса Main.

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

Советую закреплять теорию на практике. Поэтому вернитесь в блок про Error и вызовите метод notGood — увидите любопытный стектрейс.

Всё это время мы имели дело с исключением, которое бросает Java-машина — при делении на ноль. Но как вызвать исключение самим?

Раз исключение — это объект класса, то программисту всего-то и нужно, что создать объект с нужным классом исключения и бросить его с помощью оператора throw.


public static void main(String[] args) {
    hereWillBeTrouble(42, 0);
}

private static void hereWillBeTrouble(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("ты опять делишь на ноль?");
    }
    int oops = a / b;
    System.out.println(oops);
}

При создании большинства исключений первым параметром в конструктор можно передать сообщение — мы как раз сделали так выше.

А получим мы то же самое, что и в самом первом примере, только вместо стандартной фразы «/by zero» теперь выдаётся наш вопрос-пояснение «ты опять делишь на ноль?»:

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

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

Участвовать

Школа дронов для всех
Учим программировать беспилотники и управлять ими.
Узнать больше

Источник

На чтение 14 мин. Опубликовано 21.12.2020

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

В том методе, где произошла ошибка, создается и передается специальный объект. При этом метод может либо обработать исключение сам, либо пропустить его. Как бы там ни было исключение ловится и обрабатывается. Оно может появиться благодаря системе или вы можете создать его самостоятельно. Системные исключения появляются при использовании запрещенных приемов доступа к системе или неправильном использовании Java. Что касается ваших собственных исключений, то они обрабатывают специфические ошибки программы.

Рассмотрим пример с делением. Проверка соответствующего условия может предотвратить деление на ноль. Но что, если знаменатель является нулем? Если же такой нулевой знаменатель появился неожиданно, то деление невозможно и нужно возбудить исключение, и ни в коем случае не продолжать исполнение программы.

В исключениях используется пять ключевых слов: try, catch, throw, throws, finally. Схема обработки исключений следующая.

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

За передачу системных исключений отвечает сама система. Чтобы сделать это вручную, применяется throw. Созданное и передаваемое исключение внутри метода, указывается ключевым словом throws. Код, который обязательно выполнить после завершения блока try, заключается в блок finally.

Пример:

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

Для исключений существует специальный класс Trowable, в который входят 2 класса — Exception и Error. Первый используется для обработки исключений вашим приложением. Вы можете наследоваться от него, чтобы создавать собственные исключения. Класс Runtime Exception существует для распространения ошибок, который определяет ошибочную индексацию массива или обрабатывает деление на ноль.

Класс Error применяется для обработки ошибок в языке Java. Поэтому вам не придется с ним работать.
Перед тем, как научиться обрабатывать исключения, любому любопытному программисту захочется посмотреть, что же происходит, если не обработать ошибку. Давайте рассмотрим пример с делением котов на ноль:

intcatNumber;
intzero;
catNumber = 1; // у меня один кот
zero = 0; // ноль, он и в Африке ноль
intresult = catNumber / zero;

Если разместить команду в обработчик щелчка кнопки, то система времени выполнения Java выявит попытку деления на ноль, создаст объект исключения и передаст его. Но никто не перехватывает его, так как это должны быть сделать именно вы. Когда система видит вашу бездеятельность, вступает стандартный системный обработчик с вредным характером. Он остановит программу и покажет сообщение об ошибке. Его можно увидеть в журнале LogCat:

Causedby: java.lang.ArithmeticException: dividebyzeroat ru.alexanderklimov.test.MainActivity.onClick(MainActivity.java:79)

Созданный объект исключений относится к классу Arithmetic Exception. Затем системный обработчик вывел краткое описание ошибки, а также место его возникновения.

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

Разместите проблемный код в блок try и обработайте исключение в блоке catch.

intcatNumber;
intzero;

try{ // мониторим код
catNumber = 1; // у меня один кот
zero = 0; // ноль, он и в Африке ноль
intresult = catNumber / zero;
Toast.makeText(this, «Не увидите это сообщение!», Toast.LENGTH_LONG).show();
} catch (ArithmeticException e) {
Toast.makeText(this, «Нельзя котов делить на ноль!», Toast.LENGTH_LONG).show();
}
Toast.makeText(this, «Жизнь продолжается», Toast.LENGTH_LONG).show();

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

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

Операторы try и catch действуют в паре. Возможны ситуации, когда catch обрабатывает несколько вложений try.

Параметр е поможет вам увидеть описание ошибки:

catch (ArithmeticException e) {
Toast.makeText(this, e + «: Нельзя котов делить на ноль!», Toast.LENGTH_LONG).show();
}

Класс Trowable, к которому относится Arithmetic Exception, по умолчанию возвращает строку, содержащую описание исключения. Однако вы можете явно указать метод e.toString.

Несколько исключений

Код может содержать ни одно, а несколько проблемных мест. К примеру, помимо деления на ноль, может возникнуть ошибка индексации массива. В этом случае вам необходимо создавать или больше операторов catch для всех типов исключения. При этом они проверяются по порядке. Если будет обнаружено исключение у первого блока, то он будет выполнен, тогда как другие проверки пропускаются и выполнения приложения продолжается с места, следующего за блоком try/catch.

intcatNumber;
intzero;

try{ // мониторим код
catNumber = 1; // у меня один кот
zero = 1; // ноль, он и в Африке ноль
intresult = catNumber / zero;
// Создадим массив из трёх котов
String[] catNames = {«Васька», «Барсик», «Мурзик»};
catNames[3] = «Рыжик»;
Toast.makeText(this, «Не увидите это сообщение!», Toast.LENGTH_LONG).show();
} catch (ArithmeticException e) {
Toast.makeText(this, e.toString() + «: Нельзя котов делить на ноль!», Toast.LENGTH_LONG).show();
}
catch (ArrayIndexOutOfBoundsException e) {
Toast.makeText(this, «Ошибка: » + e.toString(), Toast.LENGTH_LONG).show();
}
Toast.makeText(this, «Жизнь продолжается», Toast.LENGTH_LONG).show();

В рассматриваемом примере, мы использовали массив с тремя элементами, но обращались к четвертому, поскольку забыли, что отсчет у массива начинается с нуля. Если значение переменной zero оставить равным нулю, то сработает обработка первого исключения деления на ноль. При этом мы даже не будем знать о существовании второй ошибки. Но представьте, если в результате определенных вычислений значений переменной = 1. В таком случае Arithmetic Exception не сработает, но вступит новое добавленное Array Index Out Of Bounds Exception. Дальше процесс будет таким же.

Здесь важно знать одну особенность. Используя множественные операторы catch обработки подклассов исключений должны располагаться выше по отношению обработчиков их суперклассов. В противном случае, суперкласс будет перехватывать все исключения, так как имеет большую область перехвата. Другими словами, Exception не должен располагаться выше Arithmetic Exception и Array Index Out Of Bounds Exception. Хорошо, что среда разработки сама обнаружит непорядок и обязательно вас предупредит об этом. Заметив такую ошибку, перенесите блок обработки исключений ниже.

Вложенные операторы try

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

Оператор throw

Система может обрабатывать часть исключений. Но с помощью оператора throw можно создать собственные исключения. Когда выглядит следующим образом:

throw экземпляр_Throwable

Вам необходимо создать экземпляр класса Throwable или же его наследников. Объект класса Throwable можно получить в операторе catch или традиционным способом посредством оператора new.

Пример кода для кнопки:

Catcat;

publicvoidonClick(Viewview) {
if(cat == null){
thrownewNullPointerException(«Котик не инициализирован»);
}
}

В примере был объявлен объект класса Cat, ноне проинициализированный в onCreate(). Нажатие кнопки вызовет исключение, обрабатываемое системой, а в логах вы можете увидеть сообщение об ошибке. Также можно использовать другое исключение по типу thrownewUnsupportedOperationException(«Котик не инициализирован»).

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

При этом поток выполнения останавливается после оператора throw и остальные операторы не выполняются. Ищется ближайший блок try/catch соответствующего исключению типа.

Пример кода с обработкой ошибки:

publicvoidonClick(Viewview) {
if (cat == null) {
try {
thrownewNullPointerException(«Кота не существует»);
} catch (NullPointerException e) {
Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show();
}
}
}

Был создан новый объект класса NullPointerException. По умолчанию многие классы исключений (кроме стандартного конструктора) с пустыми скобками имеют второй конструктор с строковым параметром, где можно разместить информацию об исключении. Текст из него можно получить через метод getMessage(), что собственно и было сделано в блоке catch.

Теперь программа не будет закрыта аварийно, а выведет сообщение в сплывающих Toast.

Оператор throws

В том случае, если метод может продлить исключение, которое он не обрабатывает, он должен задать данное поведение так, чтобы вызывающий его код смог бы позаботиться об этом исключении. Для этой цели к объявлению метода добавляется конструкция throws, перечисляющая типы исключений (кроме Error и Runtime Exception, а также их подклассов).

Общая форма объявления метода с использованием оператора throws:

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

В фрагменте список_исключений можно через запятую указать список исключений. Создадим метод, который продлит исключение, но не обрабатывает его. И вызовем его при нажатии на кнопку.

// Метод без обработки исключения
publicvoidcreateCat(){
Toast.makeText(this, «Вы создали котёнка», Toast.LENGTH_LONG).show();
thrownewNullPointerException(«Кота не существует»);
}

// Щелчок кнопки
publicvoidonClick(View v) {
createCat();
}

Если вы запустите пример, то получите ошибку. Исправим код.

// Без изменений
publicvoidcreateCat() throwsNullPointerException {
Toast.makeText(this, «Вы создали котёнка», Toast.LENGTH_LONG).show();
thrownewNullPointerException(«Кота не существует»);
}

// Щелчок кнопки
publicvoidonClick(View v) {
try {
createCat();
} catch (NullPointerException e) {
// TODO: handleexception
Toast.makeText(this, e.getMessage(), Toast.LENGTH_LONG).show();
}
}

Вызов метода помещен в блок try. Блок catch с необходимым типом исключения. В данном случае ошибка не произойдет.

Оператор finally

После передачи исключения, выполнения метода направляется по нелинейному пути. Это может спровоцировать проблемы. К примеру, при входе метод открывает файл, а при выходе закрывает. Чтобы из-за обработки исключения не было пропущено закрытие файла, нужно воспользоваться оператором finally.

Оператор finally создаёт блок кода, который будет выполнен после блока try/catch, но перед кодом, идущим за ним. Блок будет выполнен, невзирая на то, будет передано исключение или нет. Оператор finally не обязателен, но каждый оператор try требует наличия либо finally, либо catch.

Встроенные исключения Java

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

Illegal Monitor State Exception	Неверная операция мониторинга
Index Out of Bounds Exception	Тип индекса вышел за допустимые пределы
Array Store Exception	Присваивание элементу массива объекта несовместимого типа
Type Not Present Exception	Тип не найден
Enum Constant Not Present Exception	Попытка использования неопределённого значения перечисления
Number Format Exception	Неверное преобразование строки в числовой формат
Unsupported Operation Exception	Обнаружена неподдерживаемая операция
Arithmetic Exception	Арифметическая ошибка, к примеру, деление на ноль
Illegal Thread State Exception	Запрашиваемая операция несовместима с текущим потоком
String Index Out Of Bounds	Попытка использования индекса за пределами строки
Class Cast Exception	Неверное приведение
Security Exception	Попытка нарушения безопасности
Illegal Argument Exception	Неверный аргумент при вызове метода
Null Pointer Exception	Неверное использование пустой ссылки
Array Index Out Of Bounds Exception	Выход индекса за границу массива
Unsupported Operation Exception	Обнаружена неподдерживаемая операция
Illegal State Exception	Некорректное состояние приложения
Negative Array Size Exception	Создан массив отрицательного размера

Проверяемые системные исключения, которые можно включать в список throws.

Interrupted Exception	Поток прерван другим потоком
Class Not Found Exception	Класс не найден
No Such Field Exception	Запрашиваемое поле не существует
Illegal Access Exception	Запрещен доступ к классу
Reflective Operation Exception	Исключение, связанное с рефлексией
Instantiation Exception	Попытка создать объект абстрактного класса или интерфейса
CloneNotSupportedException	Попытка клонировать объект, который не реализует интерфейс Cloneable
No Such Method Exception	Запрашиваемый метод не существует

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

Система не в состоянии предусмотреть все исключения. В некоторых случаях придется создавать свой тип исключения для собственного приложения. Вам необходимо наследоваться от Exception (данный класс наследуется от Trowable) и переопределить необходимые методы класса Throwable. Также вы можете наследоваться уже от существующего типа, наиболее близкого по логике с исключением.

Stringget Localized Message()	Возвращает локализованное описание исключения
Final void add Suppressed (Throwable exception)	Добавляет исключение в список подавляемых исключений (JDK 7)
Void print Stack Trace (Print Writer stream)	Посылает трассировку стека в заданный поток
String get Message()	Возвращает описание исключения
Throwable fill InStack Trace()	Возвращает объект класса Throwable, содержащий полную трассировку стека
String to String()	Возвращает объект класса String, содержащий описание исключения
Void print Stack Trace()	Отображает трассировку стека
Throwable get Cause()	Возвращает исключение, лежащее под текущим исключение или null
Void set Stack Trace (Stack Trace Elementelements[])	Устанавливает трассировку стека для элементов (для специализированных приложений)
Final Throwable[] get Suppressed()	Получает подавленные исключения (JDK 7)
Stack Trace Element[] get Stack Trace()	Возвращает массив, содержащий трассировку стека и состояний из элементов класса StackTraceElement
Throwable init Cause(Throwable exception)	Ассоциирует исключение с вызывающим исключением. Возвращает ссылку на исключение

Наиболее простой способ — создать класс с конструктором по умолчанию.

// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.

packageru.alexanderklimov.exception;

importandroid.os.Bundle;
import android.support.v7.app.AppCompatActivity;
importandroid.view.View;

publicclassMainActivityextendsAppCompatActivity {

@Override
protectedvoidonCreate(BundlesavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

publicvoidtestMethod() throwsHungryCatException{
System.out.println(«Возбуждаем HungryCatException из метода testMethod()»);
thrownewHungryCatException(); // конструктор по умолчанию
}

publicvoidonClick(Viewview) {
try {
testMethod();
} catch (HungryCatException e) {
e.printStackTrace();
System.out.println(«Наше исключение перехвачено»);
}
}

classHungryCatExceptionextendsException{
}
}

В примере создан собственный класс Hungry Cat Exception, который возбужден в методе test Method(). По нажатию кнопки вызываем данный метод. Наше исключение сработает.

Несложно будет и создать класс исключения с конструктором, получающим аргумент-строку.

// Если этот код работает, его написал Александр Климов,
// а если нет, то не знаю, кто его писал.

packageru.alexanderklimov.exception;

importandroid.os.Bundle;
import android.support.v7.app.AppCompatActivity;
importandroid.view.View;

publicclassMainActivityextendsAppCompatActivity {

@Override
protectedvoidonCreate(BundlesavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

publicvoidtestMethod() throwsHungryCatException {
System.out.println(«Возбуждаем HungryCatException из метода testMethod()»);
thrownewHungryCatException(); // конструктор по умолчанию
}

publicvoid testMethod2() throwsHungryCatException {
System.out.println(«Возбуждаем HungryCatException из метода testMethod2()»);
thrownewHungryCatException(«Создано во втором методе»);
}

publicvoidonClick(Viewview) {
try {
testMethod();
} catch (HungryCatException e) {
e.printStackTrace();
System.out.println(«Наше исключение перехвачено»);
}

try {
testMethod2();
} catch (HungryCatException e) {
e.printStackTrace();
}
}

classHungryCatExceptionextendsException {
HungryCatException() {
}

HungryCatException(Stringmsg) {
super(msg);
}
}
}

Ещё вариант. Также добавим метод toString().

classCustomExceptionextendsException {
Stringmessage;

CustomException(Stringstr) {
message = str;
}

publicStringtoString() {
return («CustomExceptionOccurred: » + message);
}
}

// где-то вызываем
try {
thrownewCustomException(«Thisis a custommessage»);
} catch (CustomException e) {
System.out.println(e);
}

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

Перехват произвольных исключений

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

cacth(Exception e) {
Log.w(«Log», «Перехвачено исключение»);
}

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

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

Исключения нужно использовать для того, чтобы:

Исправить проблему и повторно вызвать метод, возбудивший исключение.
Обработать ошибку на текущем уровне (если не знаете как поступить с исключением, избегайте его перехватывания).
Предпринять все действия и продолжить выполнения без необходимости повторно вызова действий.
Завершить работу программы.
Попытаться найти альтернативное решение (результат вместо того который должен был осуществить вызванный метод).
Упростить программу (если схема обработки исключений делает все сложнее, значит она не эффективная).
Добавить программе и библиотеке безопасности.

Освоили ли вы этот материал? Какие сложности у вас возникли? Напишите ответ в комментариях.

Источник

Глава 9

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

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

Общее представление об обработке исключений

Использование ключевых слов try и catch

Простой пример обработки исключений

Последствия неперехвата исключений

Обработка исключений — изящный способ устранения программных ошибок

Применение нескольких операторов catch

Перехват исключений, генерируемых подклассами

Вложенные блоки try

Генерирование исключений

Повторное генерирование исключений

Подробнее о классе Throwable

Использование ключевого слова finally

Использование ключевого слова throws

Новые средства обработки исключений, внедренные в версии JDK 7

Встроенные в Java исключения

Создание подклассов, производных от класса Exception

Упражнение для самопроверки по материалу главы 9

Исключения

Несколько исключений

Вложенные операторы try

Оператор throw

Оператор throws

Оператор finally

Встроенные исключения Java

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

Перехват произвольных исключений

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

Исключения

Несколько исключений

Вложенные операторы try

Оператор throw

Оператор throws

Оператор finally

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

Перехват произвольных исключений

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

Реклама

Несколько исключений

Вложенные операторы try

Оператор throw

Оператор throws

Оператор finally

Встроенные исключения Java

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

Перехват произвольных исключений

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