Como é que se podem tratar exceções em Java?

Em Java, as exceções são tratadas usando a estrutura try-catch-finally ou declarando que um método pode lançar uma exceção com throws.

Formas principais:

1. Bloco try-catch-finally:

   • O código que pode causar uma exceção é colocado no bloco try.
   • O bloco catch captura e trata exceções de um tipo específico. Pode usar vários blocos catch para diferentes tipos de exceções.
   • O bloco finally é sempre executado, independentemente de uma exceção ter sido lançada ou não. É usado para liberar recursos (por exemplo, fechar fluxos).

   class Example {
       public static void main(String[] args) {
           try {
               // Código que pode lançar uma exceção
               int result = 10 / 0; // Exemplo de divisão por zero
           } catch (ArithmeticException e) {
               // Tratamento da exceção ArithmeticException
               System.err.println("Erro: divisão por zero.");
               e.printStackTrace(); // Mostrar a pilha de chamadas
           } catch (Exception e) {
               // Tratamento de qualquer outra exceção
               System.err.println("Ocorreu outro erro.");
               e.printStackTrace();
           } finally {
               // Código que sempre é executado
               System.out.println("Bloco finally executado.");
           }
       }
   }
   

2. Declaração throws:

   • Um método pode declarar que pode lançar um tipo específico de exceção usando a palavra-chave throws na assinatura do método. Isso transfere a responsabilidade de tratar a exceção para o código que chama.

   class Example {
       public static void readFile(String path) throws java.io.IOException {
           // Código que pode lançar IOException
           java.io.FileInputStream fis = new java.io.FileInputStream(path);
           // ...
       }
   
       public static void main(String[] args) {
           try {
               readFile("nonexistent_file.txt");
           } catch (java.io.IOException e) {
               System.err.println("Erro ao ler o arquivo: " + e.getMessage());
           }
       }
   }
   

3. try-with-resources (a partir do Java 7):

   • Forma especial do bloco try para gerenciar automaticamente recursos que implementam a interface AutoCloseable. Os recursos são declarados entre parênteses após a palavra-chave try, e são fechados automaticamente ao final do bloco, independentemente de uma exceção ter ocorrido ou não.

   import java.io.BufferedReader;
   import java.io.FileReader;
   import java.io.IOException;
   
   class Example {
       public static void main(String[] args) {
           try (BufferedReader br = new BufferedReader(new FileReader("my_file.txt"))) {
               // Trabalhar com o recurso (BufferedReader)
               String line;
               while ((line = br.readLine()) != null) {
                   System.out.println(line);
               }
           } catch (IOException e) {
               // Tratamento da exceção IOException
               System.err.println("Erro ao ler o arquivo: " + e.getMessage());
           }
       }
   }
   

Pontos importantes:

• Exceções verificadas vs. não verificadas: Em Java, existem exceções verificadas (por exemplo, IOException) que devem ser tratadas (catch) ou declaradas (throws), e exceções não verificadas (herdam de RuntimeException, como NullPointerException, ArithmeticException) que podem não ser tratadas explicitamente.
• Cadeias de exceções: Pode-se criar cadeias de exceções, envolvendo uma exceção em outra (throw new Exception("Mensagem", originalException)). Isso ajuda a manter a informação sobre a causa raiz do erro.
• Exceções personalizadas: Pode-se criar suas próprias classes de exceção herdando de Exception (para verificadas) ou RuntimeException (para não verificadas).