Как проверить, какой тип исключения был выброшен в Java?

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

} catch (NotAnInt e) {
    // обработка для NotAnInt
} catch (ParseError e) {
    // обработка для ParseError
}

...если только вам не нужно объединить некоторые общие шаги и вы не хотите вводить дополнительные методы ради краткости:

} catch (NotAnInt | ParseError e) {
    // шаги или два, общие для обоих случаев
    if (e instanceof NotAnInt) {
        // обработка для NotAnInt
    } else {
        // обработка для ParseError
    }
    // потенциально еще один-два общих шага для обоих случаев
}

Тем не менее, общие шаги также могут быть вынесены в методы, чтобы избежать этого блока if-else:

} catch (NotAnInt e) {
    inCommon1(e);
    // обработка для NotAnInt
    inCommon2(e);
} catch (ParseError e) {
    inCommon1(e);
    // обработка для ParseError
    inCommon2(e);
}

private void inCommon1(e) {
    // несколько шагов
    // общих для
    // обоих случаев
}
private void inCommon2(e) {
    // несколько шагов
    // общих для
    // обоих случаев
}

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

Если в одном блоке catch происходит несколько исключений, вы можете использовать оператор instanceof, чтобы распознать, какое именно исключение было выброшено.

В Java оператор instanceof используется для проверки, является ли объект экземпляром указанного типа (класса, подкласса или интерфейса).

Попробуйте следующий код:

catch (Exception e) {
    if (e instanceof NotAnInt) {
        // Ваша логика для NotAnInt.
    } else if (e instanceof ParseError) {                
        // Ваша логика для ParseError.
    }
}

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

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

try {
    int x = doSomething();
} catch (NotAnInt e) {
    // Обработка исключения NotAnInt
    System.out.println("Ошибка: значение не является целым числом.");
} catch (ParseError e) {
    // Обработка исключения ParseError
    System.out.println("Ошибка парсинга: " + e.getMessage());
}

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

Если кто-то не знал, какого типа исключение выбрасывается в методе, например, в методе с множеством возможностей, таком как этот:

public void onError(Throwable e) {

}

Вы можете получить класс исключения с помощью:

Log.e("Class Name", e.getClass().getSimpleName());

В моем случае это было UnknownHostException.

Затем используйте instanceof, как упоминалось в предыдущих ответах, чтобы выполнить определенные действия:

public void onError(Throwable e) {
    Log.e("Class Name", e.getClass().getSimpleName());

    if (e instanceof UnknownHostException) {
        Toast.makeText(context, "Не удалось установить связь с сервером", Toast.LENGTH_LONG).show();
    } else {
        // выполнить что-то другое
    }
}

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