Czy mogę złapać wiele wyjątków Java w tej samej klauzuli catch?

W Javie chcę zrobić coś takiego:

try {
    ...     
} catch (/* code to catch IllegalArgumentException, SecurityException, 
            IllegalAccessException, and NoSuchFieldException at the same time */) {
   someCode();
}

...zamiast:

try {
    ...     
} catch (IllegalArgumentException e) {
    someCode();
} catch (SecurityException e) {
    someCode();
} catch (IllegalAccessException e) {
    someCode();
} catch (NoSuchFieldException e) {
    someCode();
}

Czy jest na to sposób?

Jest to możliwe od wersji Java 7 . Składnia bloku wielozadaniowego jest następująca:

try { 
  ...
} catch (IOException | SQLException ex) { 
  ...
}

Pamiętaj jednak, że jeśli wszystkie wyjątki należą do tej samej hierarchii klas, możesz po prostu złapać ten podstawowy typ wyjątku.

Należy również pamiętać, że nie można wychwycić zarówno wyjątku A, jak i wyjątku B w tym samym bloku, jeśli wyjątek B jest dziedziczony, bezpośrednio lub pośrednio, od wyjątku A. Kompilator narzeka:

Alternatives in a multi-catch statement cannot be related by subclassing
  Alternative ExceptionB is a subclass of alternative ExceptionA

Nie dokładnie przed Javą 7, ale zrobiłbym coś takiego:

Java 6 i wcześniejsze

try {
  //.....
} catch (Exception exc) {
  if (exc instanceof IllegalArgumentException || exc instanceof SecurityException || 
     exc instanceof IllegalAccessException || exc instanceof NoSuchFieldException ) {

     someCode();

  } else if (exc instanceof RuntimeException) {
     throw (RuntimeException) exc;     

  } else {
    throw new RuntimeException(exc);
  }

}

Java 7

try {
  //.....
} catch ( IllegalArgumentException | SecurityException |
         IllegalAccessException |NoSuchFieldException exc) {
  someCode();
}

W Javie 7 możesz zdefiniować wiele klauzul catch, takich jak:

catch (IllegalArgumentException | SecurityException e)
{
    ...
}

Jeśli istnieje hierarchia wyjątków, można użyć klasy bazowej do przechwycenia wszystkich podklas wyjątków. W zdegenerowanym przypadku możesz przechwycić wszystkie wyjątki Java za pomocą:

try {
   ...
} catch (Exception e) {
   someCode();
}

W bardziej powszechnym przypadku, jeśli RepositoryException jest klasą bazową, a PathNotFoundException jest klasą pochodną, ​​to:

try {
   ...
} catch (RepositoryException re) {
   someCode();
} catch (Exception e) {
   someCode();
}

Powyższy kod przechwytuje wyjątek RepositoryException i PathNotFoundException dla jednego rodzaju obsługi wyjątków, a wszystkie pozostałe wyjątki są grupowane. Od wersji Java 7, zgodnie z odpowiedzią @ OscarRyz powyżej:

try { 
  ...
} catch( IOException | SQLException ex ) { 
  ...
}

Nie, jeden na klienta.

Możesz złapać nadklasę, taką jak java.lang.Exception, pod warunkiem, że we wszystkich przypadkach podejmiesz tę samą akcję.

try {
    // some code
} catch(Exception e) { //All exceptions are caught here as all are inheriting java.lang.Exception
    e.printStackTrace();
}

Ale to może nie być najlepsza praktyka. Powinieneś wychwycić wyjątek tylko wtedy, gdy masz strategię faktycznego obchodzenia się z nim - a rejestrowanie i ponowne zgłaszanie nie oznacza „obsługi”. Jeśli nie masz działania naprawczego, lepiej dodaj go do podpisu metody i pozwól, aby pojawił się bąbelek dla kogoś, kto poradzi sobie z sytuacją.

Czystszą (ale mniej gadatliwą i być może nie tak preferowaną) alternatywą dla odpowiedzi user454322 na Javie 6 (tj. Na Androidzie) byłoby złapanie wszystkich Exceptions i powtórne rzutowanie RuntimeException. Nie działałoby to, jeśli planujesz wychwytywać inne typy wyjątków w dalszej części stosu (chyba że je również przerzucisz ponownie), ale skutecznie złapie wszystkie sprawdzone wyjątki.

Na przykład:

try {
    // CODE THAT THROWS EXCEPTION
} catch (Exception e) {
    if (e instanceof RuntimeException) {
        // this exception was not expected, so re-throw it
        throw e;
    } else {
        // YOUR CODE FOR ALL CHECKED EXCEPTIONS
    } 
}

Biorąc to pod uwagę, dla szczegółowości najlepiej byłoby ustawić wartość logiczną lub inną zmienną i na podstawie tego wykonać jakiś kod po bloku try-catch.

W wersji wcześniejszej niż 7:

  Boolean   caught = true;
  Exception e;
  try {
     ...
     caught = false;
  } catch (TransformerException te) {
     e = te;
  } catch (SocketException se) {
     e = se;
  } catch (IOException ie) {
     e = ie;
  }
  if (caught) {
     someCode(); // You can reference Exception e here.
  }

Tak. Oto sposób użycia separatora pipe (|),

try
{
    .......
}    
catch
{
    catch(IllegalArgumentException | SecurityException | IllegalAccessException | NoSuchFieldException e)
}

W przypadku kotlina nie jest to na razie możliwe, ale rozważali możliwość dodania go: Źródło.
Na razie tylko mała sztuczka:

try {
    // code
} catch(ex:Exception) {
    when(ex) {
        is SomeException,
        is AnotherException -> {
            // handle
        }
        else -> throw ex
    }
}

Złap wyjątek, który przypadkowo jest klasą nadrzędną w hierarchii wyjątków. To oczywiście zła praktyka . W twoim przypadku częstym wyjątkiem nadrzędnym jest klasa Exception, a wyłapanie dowolnego wyjątku, który jest wystąpieniem wyjątku, jest rzeczywiście złą praktyką - wyjątki takie jak NullPointerException są zwykle błędami programowymi i zwykle powinny zostać rozwiązane poprzez sprawdzenie wartości zerowych.