Возможно ли в Java поймать два исключения в одном блоке catch? [дубликат]

этот вопрос уже есть ответ здесь:

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

catch (Exception e, ExtendsRuntimeException re) {
    // common logic to handle both exceptions
}

можно ли избежать дублирования обработчик код в каждом блоке catch?

6 ответов


Java 7 и более поздних

несколько исключений ловит поддерживаются, начиная с Java 7.

синтаксис:

try {
     // stuff
} catch (Exception1 | Exception2 ex) {
     // Handle both exceptions
}

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


Java 6 и раньше

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

подход #1

try {
     // stuff
} catch (Exception1 ex) {
     handleException(ex);
} catch (Exception2 ex) {
     handleException(ex);
}

public void handleException(SuperException ex) {
     // handle exception here
}

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

подход #2

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     } else {
         throw ex;
     }
}

еще раз, у нас есть потенциальная проблема с подписями.

подход #3

try {
     // stuff
} catch (SuperException ex) {
     if (ex instanceof Exception1 || ex instanceof Exception2) {
         // handle exception
     }
}

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


Java

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

}

документы:

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

для Java 7 Вы можете иметь несколько исключений, пойманных на одном блоке catch:

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

документы:

в Java SE 7 и более поздних версиях один блок catch может обрабатывать более одного тип исключения. Эта функция может уменьшить дублирование кода и уменьшить искушение поймать слишком широкую исключение.

ссылки: http://docs.oracle.com/javase/tutorial/essential/exceptions/catch.html


Если вы не на java 7, Вы можете извлечь обработку исключений в метод - таким образом, вы можете хотя бы минимизировать дублирование

try {
   // try something
}
catch(ExtendsRuntimeException e) { handleError(e); }
catch(Exception e) { handleError(e); }

для Java

try {
    // common logic to handle both exceptions
} catch (Exception ex) {
    if (ex instanceof Exception1 || ex instanceof Exception2) {

    }
    else {
        throw ex;
        // or if you don't want to have to declare Exception use
        // throw new RuntimeException(ex);
    }
}

отредактировано и заменено Throwable с исключением.


перед запуском Java SE 7 мы привыкли писать код с несколькими операторами catch, связанными с блоком try. Очень простой пример:

 try {
  // some instructions
} catch(ATypeException e) {
} catch(BTypeException e) {
} catch(CTypeException e) {
}

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

try {
// some instructions
} catch(ATypeException|BTypeException|CTypeException ex) {
   throw e;
}

таким образом, несколько исключений в одном предложении catch не только упрощает код но также уменьшите избыточность кода. Я нашел эту статью, которая объясняет эту функцию очень хорошо вместе с ее реализацией. улучшена и улучшена обработка исключений из Java 7 Это тоже может помочь.


http://docs.oracle.com/javase/tutorial/essential/exceptions/catch.html охватывает перехват нескольких исключений в одном блоке.

 try {
     // your code
} catch (Exception1 | Exception2 ex) {
     // Handle 2 exceptions in Java 7
}

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