Wie kann ich alle Ausnahmen erfassen, die beim Lesen und Schreiben einer Datei auftreten?

Gibt es in Java eine Möglichkeit, alle zu erhalten (zu fangen), exceptionsanstatt die Ausnahme einzeln zu fangen?

Wenn Sie möchten, können Sie Ihren Methoden Throws-Klauseln hinzufügen. Dann müssen Sie die überprüften Methoden nicht sofort abfangen. Auf diese Weise können Sie die exceptionsspäteren (möglicherweise gleichzeitig mit anderen exceptions) fangen .

Der Code sieht aus wie:

public void someMethode() throws SomeCheckedException {

    //  code

}

Dann können Sie später mit dem umgehen, exceptionswenn Sie mit ihnen in dieser Methode nicht umgehen wollen.

Um alle Ausnahmen abzufangen, kann ein Codeblock Folgendes auslösen: (Dies fängt auch ab, was ExceptionsSie selbst geschrieben haben.)

try {

    // exceptional block of code ...

    // ...

} catch (Exception e){

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

}

Der Grund dafür ist, dass Exceptiondie Basisklasse für alle Ausnahmen ist. Daher ist jede Ausnahme, die ausgelöst werden kann, ein Exception(Großbuchstabe 'E').

Wenn Sie Ihre eigenen Ausnahmen behandeln möchten, fügen Sie einfach einen catchBlock vor der generischen Ausnahme hinzu.

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

Ich bin damit einverstanden, dass es kein guter Stil ist, eine rohe Ausnahme abzufangen, aber es gibt Möglichkeiten, Ausnahmen zu behandeln, die eine überlegene Protokollierung und die Fähigkeit bieten, mit dem Unerwarteten umzugehen. Da Sie sich in einem außergewöhnlichen Zustand befinden, sind Sie wahrscheinlich mehr daran interessiert, gute Informationen zu erhalten als an der Reaktionszeit. Daher sollte die Leistung nicht zu einem großen Erfolg werden.

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

Dies berücksichtigt jedoch nicht die Tatsache, dass IO auch Fehler auslösen kann. Fehler sind keine Ausnahmen. Fehler unterliegen einer anderen Vererbungshierarchie als Ausnahmen, obwohl beide die Basisklasse Throwable gemeinsam nutzen. Da IO Fehler auslösen kann, möchten Sie möglicherweise so weit gehen, Throwable zu fangen

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

Fangen Sie die Basisausnahme 'Ausnahme' ab

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

Es ist eine schlechte Praxis, eine Ausnahme abzufangen - sie ist einfach zu weit gefasst , und Sie verpassen möglicherweise so etwas wie eine NullPointerException in Ihrem eigenen Code.

Bei den meisten Dateivorgängen ist IOException die Stammausnahme . Besser, das stattdessen zu fangen.

Ja da ist.

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

Sie können mehrere Ausnahmen in einem einzelnen Fangblock abfangen.

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

Wollen Sie damit sagen Fang ein Exceptionjeglicher Art , die ausgelöst wird, im Gegensatz zu nur bestimmte Ausnahmen?

Wenn ja:

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