Puis-je intercepter plusieurs exceptions Java dans la même clause catch?

En Java, je veux faire quelque chose comme ça:

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

...au lieu de:

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

Y a-t-il un moyen de faire ça?

Cela est possible depuis Java 7 . La syntaxe d'un bloc à prises multiples est:

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

N'oubliez pas, cependant, que si toutes les exceptions appartiennent à la même hiérarchie de classes, vous pouvez simplement intercepter ce type d'exception de base.

Notez également que vous ne pouvez pas intercepter ExceptionA et ExceptionB dans le même bloc si ExceptionB est hérité, directement ou indirectement, d'ExceptionA. Le compilateur se plaindra:

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

Pas exactement avant Java 7 mais je ferais quelque chose comme ça:

Java 6 et versions antérieures

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

Dans Java 7, vous pouvez définir plusieurs clauses catch comme:

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

S'il existe une hiérarchie d'exceptions, vous pouvez utiliser la classe de base pour intercepter toutes les sous-classes d'exceptions. Dans le cas dégénéré, vous pouvez intercepter toutes les exceptions Java avec:

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

Dans un cas plus courant, si RepositoryException est la classe de base et PathNotFoundException est une classe dérivée, alors:

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

Le code ci-dessus intercepte RepositoryException et PathNotFoundException pour un type de gestion des exceptions et toutes les autres exceptions sont regroupées. Depuis Java 7, selon la réponse de @ OscarRyz ci-dessus:

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

Non, un par client.

Vous pouvez intercepter une superclasse, comme java.lang.Exception, tant que vous effectuez la même action dans tous les cas.

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

Mais ce n'est peut-être pas la meilleure pratique. Vous ne devez intercepter une exception que si vous avez une stratégie pour la gérer réellement - et que la journalisation et la reprise ne sont pas des «manipulations». Si vous n'avez pas d'action corrective, mieux vaut l'ajouter à la signature de la méthode et la laisser bouillonner jusqu'à quelqu'un qui peut gérer la situation.

Une alternative plus propre (mais moins verbeuse, et peut-être pas aussi préférée) à la réponse de user454322 sur Java 6 (c'est-à-dire Android) serait d'attraper tous les Exceptions et de relancer les RuntimeExceptions. Cela ne fonctionnerait pas si vous envisagez d'attraper d'autres types d'exceptions plus haut dans la pile (sauf si vous les relancez également), mais interceptera efficacement toutes les exceptions vérifiées .

Par exemple:

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

Cela étant dit, pour la verbosité, il pourrait être préférable de définir un booléen ou une autre variable et en fonction de cela, exécuter du code après le bloc try-catch.

En pré-7, que diriez-vous:

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

Oui. Voici la façon d'utiliser le séparateur de tuyaux (|),

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

Pour kotlin, ce n'est pas possible pour l'instant mais ils ont envisagé de l'ajouter: Source
Mais pour l'instant, juste un petit truc:

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

Attrapez l'exception qui se trouve être une classe parente dans la hiérarchie des exceptions. C'est bien sûr une mauvaise pratique . Dans votre cas, l'exception parent commune se trouve être la classe Exception, et intercepter toute exception qui est une instance d'Exception est en effet une mauvaise pratique - les exceptions comme NullPointerException sont généralement des erreurs de programmation et doivent généralement être résolues en vérifiant les valeurs nulles.