Lancer plusieurs exceptions en Java

Je suppose que vous pourriez créer une exception contenant une liste d’exceptions détectées et lancer cette exception, par exemple:

class AggregateException extends Exception { List basket; } 

Non, il n’y a aucun moyen de faire quelque chose comme:

 try { throw new IllegalArgumentException(), new NullPointerException(); } catch (IllegalArgumentException iae) { // ... } catch (NullPointerException npe) { // ... } 

si c’est ce que vous demandez.

Vous pouvez toutefois utiliser le constructeur de cause pour effectuer les opérations suivantes:

 try { throw new IllegalArgumentException(new NullPointerException()); } catch (IllegalArgumentException iae) { // handle illegal argument... throw iae.getCause(); // throws the cause (the NullPointerException) } 

Une méthode peut générer une exception parmi plusieurs . Par exemple:

  public void dosomething() throws IOException, AWTException { // .... } 

Cela indique que la méthode peut éventuellement lancer l’ une de ces deux exceptions (et toutes les exceptions non vérifiées). Vous ne pouvez pas (en Java ou dans n’importe quel langage AFAIK) lancer simultanément deux exceptions, cela n’aurait pas beaucoup de sens.

Vous pouvez également lancer une exception nestede , qui contient un autre object exception. Mais cela ne compterait guère que “jeter deux exceptions”, cela représente simplement un cas d’exception unique décrit par deux objects d’exception (souvent issus de couches différentes).

Lancer plus d’une exception n’a pas de sens, car vous ne pouvez pas avoir plus d’une erreur (l’erreur peut avoir plusieurs raisons, mais il ne peut y avoir plus d’une erreur à la fois).

Si vous devez suivre les raisons, vous pouvez chaîner des exceptions:

 } catch (Exception ex) { throw new RuntimeException("Exc while trying ...", ex); } 

Ceux-ci sont disponibles via getCause() .

J’ai vu un modèle, où une exception personnalisée stocke en interne d’autres exceptions (je ne me souviens plus, pourquoi ils l’ont fait), mais c’était comme:

 public class ContainerException extends Exception { private List innerExeptions = new Arrayist(); // some constructors public void add(Exception e) { innerExceptions.add(e); } public Collection getExceptions() { return innerExceptions; } } 

et il a été utilisé comme ceci:

 try { // something } catch (ContainerException ce) { ce.add(new RunTimeException("some Message"); throw ce; // or do something else } 

Plus tard dans le code, l’exception de conteneur a été évaluée et exscope dans un fichier journal.

Vous pouvez avoir la possibilité de lancer plusieurs exceptions différentes. Par exemple:

 if (obj == null) throw new NullPointerException(); if (some other case) throw new IllegalArgumentException(); if (this == this) throw new IOException(); 

Ce code peut générer plusieurs exceptions différentes, mais cela ne peut jamais se produire en même temps.

Le modèle décrit par Andreas_D est certainement utile lorsque vous manipulez, par exemple, la compilation côté serveur d’un fichier fourni par l’utilisateur et que vous souhaitez signaler les erreurs.

Par exemple, vous pouvez avoir une CompilationException qui est générée si la compilation de la ressource échoue. Comstackr peut signifier n’importe quel nombre de choses. Par exemple, vous pouvez évaluer le texte à l’intérieur d’un fichier qu’un utilisateur final télécharge, parsingr des jetons, rechercher des erreurs de syntaxe et déterminer si le fichier est valide. A la fin, la chose est soit valide, soit invalide et vous souhaitez rendre une CompilationException correcte pour propager la stack d’appels.

Comme décrit par Andreas, vous pouvez avoir une méthode add () qui vous permet d’append des problèmes de compilation à votre exception. Ces problèmes ne doivent pas nécessairement être eux-mêmes, mais c’est vous qui décidez. Il est souvent utile de s’en tenir à un seul cadre d’exception pour pouvoir utiliser la même logique de validation à plusieurs endroits.

Quoi qu’il en soit, ce que vous voulez, c’est qu’une seule CompilationException retombe dans la stack d’appels, car cela indique au framework que la chose n’a pas été compilée. Si quelqu’un dans la chaîne veut savoir pourquoi, alors il peut s’attaquer aux problèmes sous-jacents en appelant, par exemple, getCauses ().

C’est également utile du sharepoint vue de l’interface utilisateur. Les informations qui circulent sur l’exception peuvent être correctement traitées avant de retourner sur le fil afin que vous puissiez donner à votre utilisateur final des informations expliquant pourquoi la compilation a échoué.

Pour lancer plusieurs exceptions en Java, vous devez d’abord supprimer chaque exception dans une exception personnalisée, puis lancer la même exception personnalisée. Veuillez vérifier l’extrait de code ci-dessous pour obtenir le même résultat.

  public class AggregateException extends Exception { public void addException(Exception ex){ addSuppressed(ex); exception = true; } } public class AnyClass{ public AggregateException aggExcep = new AggregateException(); public void whereExceptionOccurs(){ try{ //some code }catch(Exception e){ aggExcep.addException(e); //throw aggExcep; } } } 

Appelez la méthode addException avec la même référence aggExcep où vous voulez (à l’intérieur du bloc catch évidemment) supprimez toute exception. Et à la fin, lancez explicitement aggExcep en utilisant le mot-clé ‘throw’ où vous voulez.

le

void addSuppressed (exception pouvant être jetée)

est une méthode prédéfinie de classe Throwable qui ajoute l’exception spécifiée aux exceptions supprimées afin de délivrer cette exception.

il existe un moyen pour une méthode de lancer des exeptions multiples, mais pas à la fois. Par exemple, lorsque la compilation échoue pour une raison quelconque, votre méthode ne peut que lancer une exception. si vous devez couvrir différentes opportunités, vous pouvez déclarer votre méthode pour lancer la classe parente de toutes les exceptions “Exception”. donc, si vous déclarez une méthode pour lancer une exception en général, cette méthode peut générer une exception de n’importe quel type.

par exemple:

 public static void main(Ssortingng[] args) throws Exception { getClipboard(); // throws an UnsupportedFlavorException initIOActivity(); // throw an IOException } 

Je ne sais pas ce que vous aviez réellement besoin de savoir, mais peut-être que cela aide. bien que cela ait passé beaucoup de temps depuis ton post ^^

salutations

Je ne sais pas si vous demandez si plusieurs exceptions peuvent être lancées à la fois ou si nous pouvons avoir un code pour gérer plusieurs exceptions à la fois. Je vais essayer de répondre à ces deux questions. Ceci est ma première réponse sur StackOverflow, pardonnez donc toute erreur.

1) Si vous voulez lancer plusieurs exceptions à la fois, je pense que vous ne pouvez pas le faire. Considérons une situation analogue. Lorsque vous résolvez une question mathématique et atteignez un point où vous divisez par 0, il n’y a qu’une seule erreur à ce moment et qui se divise par zéro. Donc, je suppose que vous pouvez simplement jeter une erreur pour une déclaration donnée. Cependant, il peut exister de nombreuses instructions dans votre bloc try, chacune pouvant générer une erreur différente.

2) Si vous voulez gérer / intercepter plusieurs erreurs, il y a deux façons de le faire. i) Avant Java 7:

 `try{ ... //some method/action that can be a cause of multiple errors,say X and Y ... }catch(XException e){ //Do something if exception X arises. }catch(YException e){ //Do something if exception Y arises. } ` 

ii) Après Java 7, vous disposez de la fonction de capture multiple.

 try{ ... //some method/action that can be a cause of multiple errors,say X and Y ... }catch(XException|YException e){ // Take action appropriate to both types of exception. ... } 

Je crois que cela résoudra votre doute. Ceci étant ma première réponse, toutes les suggestions sont les bienvenues!