9.2 Поймание исключений

try {
    # Код, который может порождать исключения
}
```Если используется язык программирования, не поддерживающий управление исключениями, то каждому методу придётся окружить его проверками ошибок и кодом для их обнаружения — даже если метод вызывается несколько раз. В случае использования технологии управления исключениями всё можно поместить внутрь одного блока `try`, где будут пойманы все исключения. Это значительно упрощает код и делает его более читаемым, так как цель кода больше не будет смешиваться со сложной проверкой ошибок.## 9.2.2 Управители исключений

Конечно, сгенерированное исключение должно быть перехвачено где-то. Это "где-то" известно как управитель исключений или модуль управления исключениями. Для каждого типа исключений, который требуется поймать, должен существовать свой управитель исключений. Управители исключений следуют сразу после блока `try` и отмечаются ключевым словом `catch`. Пример представлен ниже:

```markdown
try {
    # Код, который может порождать исключения
} catch(Тип1 id1) {
    # Обработка исключений типа Тип1
} catch(Тип2 id2) {
    # Обработка исключений типа Тип2
} catch(Тип3 id3) {
    # Обработка исключений типа Тип3
}

# и т.д...
```Каждый `catch` — это управитель исключений, который похож на небольшой метод, требующий одного конкретного типа параметра. Внутри контроллера можно использовать идентификаторы (`id1`, `id2` и т.д.), как обычные параметры метода. Иногда идентификаторы вообще не используются, поскольку тип исключения предоставляет достаточно информации для эффективной обработки исключения. Однако, даже если они не используются, идентификаторы должны находиться на своих местах. Контроллер должен находиться "немедленно" после блока `try`. Если будет "выброшено" исключение, механизм управления исключениями будет искать первый контроллер с совпадающими параметрами и типом исключения. Затем он войдет в этот блок `catch`, считая, что исключение было обработано (поиск контроллера прекращается сразу же после завершения блока `catch`). Только соответствующий блок `catch` будет выполнен; это отличается от конструкции `switch`, где требуется команда `break` после каждого `case`, чтобы предотвратить случайное выполнение других операторов.Внутри блока `try` обратите внимание на то, что множество различных вызовов методов могут генерировать одно и то же исключение, но потребуется всего один обработчик.

### 9.2.2 Прерывание и восстановление

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

Другой подход называется "восстановлением". Это значит, что обработчик исключений обязан исправить текущее состояние и затем получить метод, который вызвал ошибку, предполагая, что следующая попытка выполнения будет успешной. Если используется восстановление, это означает, что вы хотите продолжить выполнение даже после того, как исключение было обработано. В этом случае наша ошибка больше похожа на вызов метода — мы используем его для установки специальных условий в Java, которые приводят к поведению, похожему на "восстановление" (то есть, вместо бросания исключения, мы вызываем метод для решения проблемы). Кроме того, можно поместить свой блок `try` внутрь цикла `while`, чтобы постоянно входить в блок `try`, пока не будет достигнут желаемый результат.Из исторической перспективы, если программист использует операционную систему, поддерживающую управление исключениями с возможностью восстановления, в конечном итоге всё равно придётся использовать код, аналогичный прерыванию, и пропустить процесс восстановления. Поэтому, хотя "восстановление" кажется идеальным решением, на практике оно оказывается сложным. Основной причиной может быть необходимость контроля за тем, были ли созданы исключения, а также наличием специализированного кода для места их создания. Это делает код трудным для написания и поддержки, особенно в больших системах, где исключения могут создаваться в нескольких местах.## 9.2.3 Нормы исключений

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

Аннотация `throws` использует дополнительное ключевое слово: `throws`; за которым следует полный список потенциальных типов исключений. Таким образом, наш метод теперь выглядит следующим образом:```markdown
void f() throws tooBig, tooSmall, divZero { //...

void f() [ // ...

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

```markdown
catch (Exception e) {
    System.out.println("caught an exception");
}

getMessage()

toString()

printStackTrace()
printStackTrace(PrintStream)

//: ExceptionMethods.java
// Демонстрация методов исключений
package c09;

public class ExceptionMethods {
  public static void main(String[] args) {
    try {
      throw new Exception("Здесь мое исключение");
    } catch(Exception e) {
      System.out.println("Поймано исключение");
      System.out.println(
        "e.getMessage(): " + e.getMessage());
      System.out.println(
        "e.toString(): " + e.toString());
      System.out.println("e.printStackTrace():");
      e.printStackTrace();
    }
  }
} ///:~

Поймано исключение
e.getMessage(): Здесь мое исключение
e.toString(): java.lang.Exception: Здесь мое исключение
e.printStackTrace():
java.lang.Exception: Здесь мое исключение
        at ExceptionMethods.main
```Как видно, этот метод предоставляет множество информации — каждая последующая категория информации является подмножеством предыдущей категории.

## Переброска Исключений

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

```catch(Exception e) {
    System.out.println("Произошла ошибка");
    throw e;
}

//: Перебрасывание.java
// Демонстрация fillInStackTrace()
``````java
public class Перебрасывание {
  public static void f() throws Исключение {
    System.out.println("генерация исключения в f()");
    throw new Исключение("выброшено из f()");
  }
  public static void g() throws Бросаемое {
    try {
      f();
    } catch (Исключение e) {
      System.out.println("внутри g(), e.printStackTrace()");
      e.printStackTrace();
      throw e; // 17
      // throw e.fillInStackTrace(); // 18
    }
  }
  public static void main(String[] args) throws Бросаемое {
    try {
      g();
    } catch (Исключение e) {
      System.out.println("поймано в main, e.printStackTrace()");
      e.printStackTrace();
    }
  }
}
///:~

генерация исключения в f()
внутри g(), e.printStackTrace()
java.lang.Exception: выброшено из f()
        at Перебрасывание.f(Перебрасывание.java:8)
        at Перебрасывание.g(Перебрасывание.java:12)
        at Перебрасывание.main(Перебрасывание.java:24)
поймано в main, e.printStackTrace()
java.lang.Exception: выброшено из f()
        at Перебрасывание.f(Перебрасывание.java:8)
        at Перебрасывание.g(Перебрасывание.java:12)
        at Перебрасывание.main(Перебрасывание.java:24)

генерация исключения в f()
внутри g(), e.printStackTrace()
java.lang.Exception: выброшено из f()
        at Rethrowing.f(Rethrowing.java:8)
        at Rethrowing.g(Rethrowing.java:12)
        at Rethrowing.main(Rethrowing.java:24)
поймано в main, e.printStackTrace()
java.lang.Exception: выброшено из f()
        at Rethrowing.g(Rethrowing.java:18)
        at Rethrowing.main(Rethrowing.java:24)
```Использование `fillInStackTrace()` делает 18-ю строку новым источником исключения.

Для методов `g()` и `main()` класс `Throwable` должен присутствовать в спецификации выбрасываемых исключений, так как `fillInStackTrace()` создаёт ссылку на объект типа `Throwable`. Поскольку `Throwable` является базовым классом для `Exception`, это может привести к ситуации, когда ссылка на объект типа `Throwable` будет указывать на что-то, что не является экземпляром `Exception`. В результате, ссылка на `Exception` внутри `main()` может потерять свою целостность. Чтобы гарантировать корректность всех операций, компилятор требует использования спецификации исключений для `Throwable`.

Например, исключение в следующей программе не будет поймано в `main()`:

```java
//: ThrowOut.java
public class ThrowOut {
  public static void
  main(String[] args) throws Throwable {
    try {
      throw new Throwable();
    } catch(Exception e) {
      System.out.println("Поймано в main()");
    }
  }
} ///:~

//: RethrowNew.java
// Перебросить другой объект вместо того, который был пойман
``````java
public class RethrowNew {
  public static void f() throws Exception {
    System.out.println(
      "генерация исключения в f()");
    throw new Exception("выброшено из f()");
  }

  public static void main(String[] args) {
    try {
      f();
    } catch (Exception e) {
      System.out.println(
        "Поймано в main, e.printStackTrace()");
      e.printStackTrace();
      throw new NullPointerException("из main");
    }
  }
}
///:~

Последний бросаемый **исключение** знает только то, что он происходит из `main()`, а не из `f()`. Обратите внимание, что `Throwable` не является обязательным в любом спецификаторе исключений.

Никогда не следует заботиться о том, как очистить предыдущее исключение или какие-либо другие исключения, связанные с ним. Они являются объектами, созданными с помощью `new`, основанными на куче памяти, поэтому сборщик мусора автоматически освобождает их.