¿Cómo puedo detectar todas las excepciones que se generarán al leer y escribir un archivo?

En Java, ¿hay alguna forma de obtener (capturar) todo en exceptionslugar de capturar la excepción individualmente?

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

El código se ve así:

public void someMethode() throws SomeCheckedException {

    //  code

}

Luego, más tarde puedes lidiar con el exceptions si no quieres lidiar con ellos en ese método.

Para detectar todas las excepciones, puede que algún bloque de código arroje lo siguiente: (Esto también detectará Exceptionsque escribió usted mismo)

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 Exceptiones la clase base para todas las excepciones. Por lo tanto, cualquier excepción que pueda arrojarse es una Exception('E' mayúscula).

Si desea manejar sus propias excepciones primero, simplemente agregue un catchbloque antes de la excepción genérica.

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

Si bien estoy de acuerdo que no es un buen estilo detectar 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 lanzar 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;
    }
}

Captura la excepción base 'Exception'

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

Es una mala práctica detectar la excepción : es demasiado amplia y puede perder algo como una NullPointerException en su propio código.

Para la mayoría de las operaciones de archivos, IOException es la excepción raíz. Mejor captar eso, en cambio.

Sí hay.

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

Puede detectar múltiples excepciones en un solo bloque de captura.

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

¿Te refieres a atrapar un Exceptionde cualquier tipo? que se lanza, en lugar de solo Excepciones específicas?

Si es así:

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