Comment puis-je détecter toutes les exceptions qui seront levées lors de la lecture et de l'écriture d'un fichier?

En Java, existe-t-il un moyen d'obtenir (attraper) tout exceptionsau lieu d'attraper l'exception individuellement?

Si vous le souhaitez, vous pouvez ajouter des clauses throws à vos méthodes. Ensuite, vous n'avez pas à attraper les méthodes vérifiées tout de suite. De cette façon, vous pouvez attraper le exceptionsplus tard (peut-être en même temps que l'autre exceptions).

Le code ressemble à ceci:

public void someMethode() throws SomeCheckedException {

    //  code

}

Ensuite, vous pourrez vous en occuper plus tard exceptionssi vous ne voulez pas les traiter de cette manière.

Pour attraper toutes les exceptions, un bloc de code peut lancer, vous pouvez le faire: (Cela détectera également que Exceptionsvous avez écrit vous-même)

try {

    // exceptional block of code ...

    // ...

} catch (Exception e){

    // Deal with e as you please.
    //e may be any type of exception at all.

}

La raison pour laquelle cela fonctionne est que Exceptionc'est la classe de base pour toutes les exceptions. Ainsi, toute exception qui peut être levée est un Exception(«E» majuscule).

Si vous souhaitez d'abord gérer vos propres exceptions, ajoutez simplement un catchbloc avant l'exception générique.

try{    
}catch(MyOwnException me){
}catch(Exception e){
}

Bien que je convienne que ce n'est pas un bon style d'attraper une exception brute, il existe des moyens de gérer les exceptions qui fournissent une journalisation supérieure et la capacité de gérer l'inattendu. Étant donné que vous êtes dans un état exceptionnel, vous êtes probablement plus intéressé par l'obtention de bonnes informations que par le temps de réponse, donc l'instance de performance ne devrait pas être un grand succès.

try{
    // IO code
} catch (Exception e){
    if(e instanceof IOException){
        // handle this exception type
    } else if (e instanceof AnotherExceptionType){
        //handle this one
    } else {
        // We didn't expect this one. What could it be? Let's log it, and let it bubble up the hierarchy.
        throw e;
    }
}

Cependant, cela ne prend pas en compte le fait que IO peut également générer des erreurs. Les erreurs ne sont pas des exceptions. Les erreurs sont sous une hiérarchie d'héritage différente de celle des exceptions, bien que les deux partagent la classe de base Throwable. Étant donné que IO peut lancer des erreurs, vous voudrez peut-être aller jusqu'à attraper Throwable

try{
    // IO code
} catch (Throwable t){
    if(t instanceof Exception){
        if(t instanceof IOException){
            // handle this exception type
        } else if (t instanceof AnotherExceptionType){
            //handle this one
        } else {
            // We didn't expect this Exception. What could it be? Let's log it, and let it bubble up the hierarchy.
        }
    } else if (t instanceof Error){
        if(t instanceof IOError){
            // handle this Error
        } else if (t instanceof AnotherError){
            //handle different Error
        } else {
            // We didn't expect this Error. What could it be? Let's log it, and let it bubble up the hierarchy.
        }
    } else {
        // This should never be reached, unless you have subclassed Throwable for your own purposes.
        throw t;
    }
}

Attrapez l'exception de base «Exception»

   try { 
         //some code
   } catch (Exception e) {
        //catches exception and all subclasses 
   }

Attraper Exception est une mauvaise pratique - c'est tout simplement trop large et vous risquez de manquer quelque chose comme une NullPointerException dans votre propre code.

Pour la plupart des opérations sur les fichiers, IOException est l'exception racine. Mieux vaut attraper ça, à la place.

Oui il y a.

try
{
    //Read/write file
}catch(Exception ex)
{
    //catches all exceptions extended from Exception (which is everything)
}

Vous pouvez intercepter plusieurs exceptions dans un seul bloc catch.

try{
  // somecode throwing multiple exceptions;
} catch (Exception1 | Exception2 | Exception3 exception){
  // handle exception.
} 

Voulez-vous dire attraper un Exceptionde n'importe quel type qui est lancé, par opposition à seulement des exceptions spécifiques?

Si c'est le cas:

try {
   //...file IO...
} catch(Exception e) {
   //...do stuff with e, such as check its type or log it...
}