Como posso capturar todas as exceções que serão lançadas durante a leitura e gravação de um arquivo?

Em Java, existe alguma maneira de obter (capturar) tudo em exceptionsvez de capturar a exceção individualmente?

Se desejar, você pode adicionar cláusulas throws aos seus métodos. Então você não precisa pegar os métodos verificados imediatamente. Dessa forma, você pode capturar o exceptionsúltimo (talvez ao mesmo tempo que outro exceptions).

O código se parece com:

public void someMethode() throws SomeCheckedException {

    //  code

}

Então, mais tarde, você pode lidar com os exceptionsse não quiser lidar com eles desse método.

Para capturar todas as exceções que algum bloco de código pode lançar, você pode fazer: (Isso também pegará Exceptionsvocê mesmo)

try {

    // exceptional block of code ...

    // ...

} catch (Exception e){

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

}

O motivo pelo qual funciona é porque Exceptioné a classe base para todas as exceções. Portanto, qualquer exceção que possa ser lançada é um Exception('E' maiúsculo).

Se você quiser lidar com suas próprias exceções primeiro, simplesmente adicione um catchbloco antes da exceção genérica.

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

Embora eu concorde que não é um bom estilo capturar uma exceção bruta, existem maneiras de lidar com exceções que fornecem um registro superior e a capacidade de lidar com o inesperado. Como você está em um estado excepcional, provavelmente está mais interessado em obter boas informações do que no tempo de resposta, portanto, a ocorrência de desempenho não deve ser um grande golpe.

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

No entanto, isso não leva em consideração o fato de que o IO também pode lançar erros. Erros não são exceções. Os erros estão em uma hierarquia de herança diferente das Exceções, embora ambos compartilhem a classe base Throwable. Uma vez que IO pode lançar erros, você pode querer ir tão longe a ponto de pegar lançável

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

Capture a exceção de base 'Exceção'

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

É uma má prática capturar Exception - é muito ampla, e você pode perder algo como um NullPointerException em seu próprio código.

Para a maioria das operações de arquivo, IOException é a exceção raiz. Melhor pegar isso, em vez disso.

Sim existe.

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

Você pode capturar várias exceções em um único bloco catch.

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

Você quer dizer pegar um Exceptionde qualquer tipo que seja lançado, ao invés de apenas exceções específicas?

Se então:

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