Java деление на ноль какая ошибка

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поместим проблемный код в блок 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();

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

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

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

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

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

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

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

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

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

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

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

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

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

Оператор throw

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

throw экземпляр_Throwable

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

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

Cat cat;

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

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

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

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

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

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

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

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

Оператор throws

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

Общая форма объявления метода с оператором 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

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

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

Существуют несколько готовых системных исключений. Большинство из них являются подклассами типа 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, содержащий описание исключения.

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

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

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{
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

Реклама

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

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

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("Всё, что будет после...");
}

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("Метод отработал");
}

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

Как зарабатывать больше с помощью нейросетей?
Бесплатный вебинар: 15 экспертов, 7 топ-нейросетей. Научитесь использовать ИИ в своей работе и увеличьте доход.
Узнать больше

Содержание

• 1. Что такое исключительная ситуация?
• 2. Понятие исключения в языке Java
• 3. Какими способами могут генерироваться исключения?
• 4. В каких случаях вызывается стандартный обработчик исключений Java?
• 5. Какие ключевые слова используются для обработки исключений в Java?
• 6. Какое назначение конструкции try…catch…finally? Общая форма
• 7. Пример генерирования исключения и его перехват стандартным обработчиком исключений Java
• 8. Пример перехвата и обработки исключения с помощью оператора try…catch
• 9. Пример перехвата и обработки исключения блоком try…catch…finally. Демонстрация работы блока операторов finally
• 10. Как реализовать вывод описания исключения? Пример
• 11. Пример перехвата нескольких исключительных ситуаций (несколько операторов catch)
• Связанные темы

Поиск на других ресурсах:

1. Что такое исключительная ситуация?

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

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

Правильная обработка исключений есть важным элементом написания профессиональных программ на Java.

  ⇑

2. Понятие исключения в языке Java

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

В языке программирования Java, исключение – это специальный объект, описывающий исключительную ситуацию, которая возникла в некоторой части программного кода. Объект представляющий исключение, генерируется в момент возникновения исключительной ситуации. После возникновения критической (исключительной) ситуации исключение перехватывается и обрабатывается. Таким образом, возникает понятие генерирования исключения. Генерирование исключения – процесс создания объекта, который описывает данное исключение.

  ⇑

3. Какими способами могут генерироваться исключения?

В языке Java исключения могут генерироваться одним из двух способов:

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

  ⇑

4. В каких случаях вызывается стандартный обработчик исключений Java?

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

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

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

  ⇑

5. Какие ключевые слова используются для обработки исключений в Java?

Для обработки исключений в Java используются следующие ключевые слова:

• try;
• catch;
• throw;
• throws;
• finally.

  ⇑

6. Какое назначение конструкции try… catch…finally? Общая форма

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

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

try {
    // блок кода, в котором отслеживаются и генерируются исключения
    // ...
}
catch (type_exception_1 objEx1) {
    // обработчик исключения типа type_exception_1
    // ...
}
catch (type_exception_2 objEx2) {
    // обработчик исключения типа type_exception_2
    // ...
}

...

catch (type_exception_N objEx) {
    // обработчик исключения типа type_exception_N
    // ...
}
finally {
    // блок кода, который должен быть обязательно выполнен
    // после завершения блока try
    // ...
}

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

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

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

Операторы try и catch составляют единое целое. Оператор finally может отсутствовать.

  ⇑

7. Пример генерирования исключения и его перехват стандартным обработчиком исключений Java

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

Объявляется класс DemoExceptions. С целью демонстрации в классе объявляется метод DivNumbers(). Метод возвращает число типа double, которое есть результатом деления двух целых значений переменных a и b. Эти переменные есть входными параметрами метода.

Если b = 0 то при делении a на b может возникнуть исключительная ситуация «деление на нуль» типа ArithmeticException. В программе нет кода, который явным образом перехватывает и обрабатывает эту ситуацию. Поэтому, вызывается стандартный обработчик Java.

Текст класса DemoExceptions следующий:

// класс реализующий метод,
// в котором может возникнуть исключительная ситуация
class DemoExceptions {

    // метод, в котором может возникнуть деление на 0
    double DivNumbers(int a, int b) {

        // при делении на 0 будет вызван стандартный обработчик Java
        double res;
        res = a/b;
        return res;
    }
}

Если в другом классе использовать метод DivNumbers() следующим образом

public class Train01 {

    public static void main(String[] args) {
        DemoExceptions d = new DemoExceptions(); // создать экземпляр класса
        double res;

        // вызвать метод DivNumbers()
        res = d.DivNumbers(2, 0); // 2/0 => деление на ноль
        System.out.println("res = " + res);
    }
}

то будет вызванный стандартный обработчик Java, который выведет следующее сообщение

Exception in thread "main" java.lang.ArithmeticException: / by zero
at DemoExceptions.DivNumbers(Train01.java:10)
at Train01.main(Train01.java:82)

В сообщении указывается тип класса ArithmeticException. Это подкласс производный от класса RunTimeException. Этот подкласс описывает арифметические ошибки «деление на 0», «взятие корня из отрицательного числа» и т.п..

  ⇑

8. Пример перехвата и обработки исключения с помощью оператора try…catch

В примере реализован класс DemoExceptions, в котором объявляется метод с именем DivNumbers2(). Метод DivNumbers2() делит входящий параметр a на входящий параметр b. В методе DivNumbers2() продемонстрирован перехват исключения деления на ноль с помощью блока try…catch.

Текст класса DemoExceptions следующий

// класс реализующий метод,
// в котором может возникнуть исключительная ситуация
class DemoExceptions {

    // метод, в котором обработано деление на 0,
    // блок try..catch
    double DivNumbers2(int a, int b) {
        double res=0; // переменная res обязательно должна быть инициализирована

        try {
            res = a/b; // если b=0, то генерируется исключение
        }
        catch (ArithmeticException e) {
            System.out.println("Деление на 0.");
        }

        return res;
    }
}

Теперь, при использовании метода DivNumbers2() в другом классе

public class Train01 {

    public static void main(String[] args) {
        DemoExceptions d = new DemoExceptions(); // создать экземпляр класса
        double res;

        // вызвать метод DivNumbers2()
        res = d.DivNumbers2(2, 0); // 2/0 => деление на ноль

        System.out.println("res = " + res);
    }
}

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

Деление на 0.
res = 0.0

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

...
res = a/b;
...

Если возникает исключение (b=0), то управление сразу передается из блока try в блок catch. В блоке catch происходит обработка исключения с выводом соответствующего сообщения

...
catch (ArithmeticException e) {
    System.out.println("Деление на 0.");
}
...

Итак, если b=0:

• генерируется исключение типа ArithmeticException;
• происходит переход к обработке исключения (блок catch);
• в блоке catch выводится соответствующее сообщение;
• после блока catch выполнение программы не останавливается. В результате переменная res получает значение 0.

Можно изменить вывод собственного сообщения об исключении на стандартное сообщение. В этом случае нужно изменить текст в блоке catch на следующий

...
catch (ArithmeticException e) {
    System.out.println(e);
    //System.out.println("Деление на 0.");
}
...

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

java.lang.ArithmeticException: / by zero
res = 0.0

  ⇑

9. Пример перехвата и обработки исключения блоком try…catch…finally. Демонстрация работы блока операторов finally

В примере продолжено развитие двух предшествующих пунктов 7, 8. Пример демонстрирует назначение блока finally в операторе try…catch…finally.

Объявляется класс DemoExceptions. В классе продемонстрирован перехват исключительной ситуации деления на 0. Этот перехват реализован в методе DivNumbers3() класса. Для перехвата и обработки исключительной ситуации, метод DivNumbers3() использует оператор try…catch…finally.

Текст класса DemoExceptions следующий

// класс, который реализует метод,
// в котором может возникнуть исключительная ситуация
class DemoExceptions {

    // метод, в котором обработано деление на 0,
    // блок try..catch..finally
    double DivNumbers3(int a, int b) {
        double res; // не обязательно инициализировать, поскольку есть блок finally
        try {
            res = a/b;
        }
        catch (ArithmeticException e) {
            System.out.println("Деление на 0.");
        }
        finally {
            res = 0; // вызовется обязательно
        }
        return res;
    }
}

В методе DivNumbers3() объявляется переменная res, что есть результатом деления a на b. Поскольку оператор try…catch содержит блок finally, то строка

...
finally {
    res = 0; // вызовется обязательно
}
...

будет вызываться всегда. И перед оператором

...
return res;
...

переменная res будет всегда инициализирована. Поэтому компилятор Java не требует инициализации переменной в начале кода. Как известно, чтобы возвратить значение переменной оператором return, эта переменная должна быть обязательно инициализирована. Итак, блок finally вызывается всегда.

Использование метода DivNumbers3() в другом классе может быть следующим

public class Train01 {

    public static void main(String[] args) {
        DemoExceptions d = new DemoExceptions();
        double res;
        res = d.DivNumbers3(2, 0); // 2/0 => деление на ноль
        System.out.println("res = " + res);
    }
}

Результат выполнения программы

Деление на 0.
res = 0.0

  ⇑

10. Как реализовать вывод описания исключения? Пример

Если нужно вывести описание исключения e, то можно изменить вывод в обработчике catch следующим образом (см. пункт 8)

...
catch (ArithmeticException e) {
    // перехватить ошибку деления на 0
    System.out.println("Исключение: " + e);
}
...

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

Исключение: java.lang.ArithmeticException: / by zero

  ⇑

11. Пример перехвата нескольких исключительных ситуаций (несколько операторов catch)

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

Реализация класса DivArrays следующая

// несколько операторов catch
// класс, который делит поэлементно массивы
class DivArrays {
    double[] A1;
    double[] A2;

    // конструктор класса
    DivArrays(int n1, double[] _A1, int n2, double[] _A2) {
        // создать массивы
        A1 = new double[n1];
        for (int i=0; i<n1; i++)
            A1[i] = _A1[i];

        A2 = new double[n2];
        for (int i=0; i<n2; i++)
            A2[i] = _A2[i];
    }

    // метод, который делит поэлементно массив A1 на массив A2
    // метод возвращает массив типа double
    double[] Division() {
        double[] A3;
        int n3;

        // установить наибольший из размеров
        if (A1.length > A2.length)
            n3 = A1.length;
        else
            n3 = A2.length;

        A3 = new double[n3];

        // цикл по i, в цикле обрабатывается исключительная ситуация
        for (int i=0; i<n3; i++) {
            try {
                // сгенерировать исключение, если деление на 0
                if (A2[i]==0.0)
                    throw new ArithmeticException();
                A3[i] = A1[i]/A2[i];
            }
            catch (ArithmeticException e) {
                // перехватить деление на 0
                A3[i] = 0; // просто установить в A3 значение 0
            }
            catch (ArrayIndexOutOfBoundsException e) {
                // перехватить выход индекса за границы массива
                // это случай, когда длины массивов отличаются
                A3[i] = -1;
            }
        }
        return A3;
    }
}

Использование класса в другом программном коде

public class Train03 {

    public static void main(String[] args) {
        double[] A1 = { 2.5, 2.0, 1.5, 0.5 };
        double[] A2 = { 1.0, 0.0, 2.0 };
        double[] A3;

        DivArrays dA = new DivArrays(4,A1,3,A2);

        A3 = dA.Division();

        // вывести массив d
        for (int i=0; i<A3.length; i++)
            System.out.println("A[" + i + "] = " + A3[i]);
    }
}

Результат выполнения программы

A[0] = 2.5
A[1] = 0.0
A[2] = 0.75
A[3] = -1.0

  ⇑

Связанные темы

• Операторы throw, throws. Примеры
• Классы Java для обработки исключительных ситуаций из пакета java.lang. Методы класса Throwable. Примеры
• Класс Exception. Создание собственных классов исключений. Примеры

  ⇑