¿Cómo puedo detectar todas las excepciones lanzadas al leer/escribir un archivo?

En Java, ¿hay alguna forma de obtener (atrapar) todos exceptions en lugar de capturar las excepciones individualmente?

Si lo desea, puede agregar cláusulas throws a sus métodos. Entonces no tiene que capturar los métodos marcados de inmediato. De esa manera, puedes atrapar el exceptions más tarde (quizás al mismo tiempo que otros exceptions).

El código se parece a:

public void someMethode() throws SomeCheckedException {

    //  code

}

Luego, más tarde, puede lidiar con el exceptions si no quieres tratar con ellos de esa manera.

Para capturar todas las excepciones que algún bloque de código puede arrojar, puede hacer lo siguiente: (Esto también capturará Exceptions tu mismo escribiste)

try {

    // exceptional block of code ...

    // ...

} catch (Exception e){

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

}

La razón por la que funciona es porque Exception es la clase base para todas las excepciones. Por lo tanto, cualquier excepción que pueda ser lanzada es una Exception (‘E’ mayúscula).

Si desea manejar sus propias excepciones primero simplemente agregue un catch bloque antes de la Excepción genérica uno.

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

Si bien estoy de acuerdo en que no es un buen estilo capturar una excepción sin procesar, hay formas de manejar las excepciones que brindan un registro superior y la capacidad de manejar lo inesperado. Dado que se encuentra en un estado excepcional, probablemente esté más interesado en obtener buena información que en el tiempo de respuesta, por lo que la instancia de rendimiento no debería ser un gran éxito.

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

Sin embargo, esto no tiene en cuenta el hecho de que IO también puede generar errores. Los errores no son excepciones. Los errores están bajo una jerarquía de herencia diferente a las excepciones, aunque ambos comparten la clase base Throwable. Dado que IO puede arrojar errores, es posible que desee ir tan lejos como para atrapar 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;
    }
}

Atrapa la excepción base ‘Excepción’

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

Puede capturar varias excepciones en un solo bloque de captura.

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

Es una mala práctica atrapar Excepción — es demasiado amplio, y es posible que se pierda algo como un Excepción de puntero nulo en su propio código.

Para la mayoría de las operaciones con archivos, IOException es la excepción raíz. Mejor atrapar eso, en su lugar.

¿Quieres decir atrapar un Exception de cualquier tipo que se lanza, en lugar de solo excepciones específicas?

En ese caso:

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

Sí hay.

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