Java: Comment lancer une Exception à la méthode de l'appelant à l'intérieur d'un try catch corps?

Quand j'ai une méthode comme ceci:

public static void foo(String param) throws IOException
{
    try
    {
         //some IOoperations
         if (param.isEmpty())
         {
              throw new IOException("param is empty");
         }
         //some other IOoperations

    } catch (Exception e) {
        /* handle some possible errors of of the IOoperations */
    }
}

Et lorsque le IOException ("param est vide") est lancée, il est piégé par la try-catch dans ce corps. Mais cette exception est destiné à l'appelant de cette méthode. Comment puis-je faire cela correctement? Est-il quelque chose de "pure Java" pour ce faire ou dois-je créer un autre type d'Exception qui n'est pas une instance de IOException pour éviter le try-catch corps va la traiter?

Je sais vous suggérons d'utiliser un IllegalArgumentException dans ce cas. Mais c'est un exemple simplifié de ma situation. En fait l'Exception je lancer est une IOException.

Grâce

OriginalL'auteur Martijn Courteaux | 2010-10-01

7

Faire votre propre sous-classe de IOException pourrait être une bonne idée. Non seulement pour résoudre ce problème, mais il est parfois un peu "plus convivial" pour votre les utilisateurs de l'API.

Ensuite, vous pouvez l'ignorer en bloc catch (renvoyer immédiatement)
```
} catch (FooIOException e) {
    throw e;
} catch (Exception e) {
    /* handle some possible errors of of the IOoperations */
}
```
OriginalL'auteur Nikita Rybak
3

Je pense que je suis confus par les spécificités de votre exemple-pourquoi êtes-vous à la large
```
} catch (Exception e) {
```
Si c'est trop générique clause catch n'était pas là, le problème ne se poserait plus.

Fait que j'ai mal compris?

D'accord. C'est rarement une bonne idée d'attraper une Exception ou RuntimeException. En général, vous voulez rattraper les plus spécifiques des sous-classes. Et merci de ne pas jamais JAMAIS les attraper à Lancer ou d'Erreur.

OriginalL'auteur andersoj
2

Vous pouvez vérifier si votre exception est une instance de IOException et si elle l'est, renvoyer.
```
catch( Exception e ) {
  if( e instanceof IOException ) {
    throw (IOException)e;
  }
}
```
Il voulait juste la poignée IOException s autres que la main levée. Btw, j'aimerais ajouter un autre catch bloc plutôt que de faire un instanceof dans ce cas particulier.
Merci, mais toutes les exceptions levées dans cette méthode sont IOExceptions... (BTW: Félicitations pour vos 10 000 points!)
De 10 000 à attendre jusqu'à demain. Aujourd'hui, la limite de 200 est déjà atteint 🙁
Pas si votre réponse accepté... 🙂
Pas celui-ci, il y a trop de réponses qui sont meilleures que les miennes.

OriginalL'auteur tangens

Vous pouvez l'attraper, et re-jeter, mais la solution correcte devrait être d'être plus sélectif de ce que vous êtes chasse dans votre instruction catch....

Par exemple. Dans le code ci-dessous, je suis d'attraper un FileNotFoundException, de sorte que le IOException est renvoyée à la méthode appelante.

public static void foo(String param) throws IOException {
        try {
         //some IOoperations
         if (param.isEmpty())
         {
              throw new IOException("param is empty");
         }
         //some other IOoperations

        } catch (FileNotFoundException e) {
            /* handle some possible errors of of the IOoperations */
        }
    }

OriginalL'auteur Codemwnci

0

Je voudrais créer une sous-classe de IOException. Cela vous permettra d'utiliser un instanceof de vérifier et de les renvoyer.

Et il y a très peu de cas où j'utilise catch (Exception). Il est presque toujours préférable d'attraper les exceptions spécifiques. La seule raison de ne pas, c'est quand vous voulez agréger les exceptions et les renvoyer (réflexion opérations sont un lieu commun de le faire).

OriginalL'auteur Anon

Si IOExceptions sont fait l'un pour l' foo() de l'appelant, vous pouvez le faire:

public static void foo(String param) throws IOException
{
    try
    {
         //some IOoperations
         if (param.isEmpty())
         {
              throw new IOException("param is empty");
         }
         //some other IOoperations

    } catch (IOException e) {
        throw e;
    } catch (Exception e) {
        /* handle some possible errors of of the IOoperations */
    }

}

Si l'exception est le seul qui avait vraiment besoin d'être relancés, puis créer un nouveau sous-type de IOException nom il MyException et essayer d'attraper MyException à relever.

Tout pokemon la gestion des exceptions est très laid !

Bravo pour le 10k. 46 jours; je pense que c'est un nouveau record 🙂
Merci 🙂

OriginalL'auteur Colin Hebert

Vous devez vous connecter pour publier un commentaire.