Tratamento de Exceções / Erros

[JayCesar]

📚 O que é uma exceção?

É um evento que ocorre durante a execução de um programa que interrompe o seu fluxo normal de execução. O java direciona esse erro para algum local que saiba tratar, isso se chama cadeia de comando.

Excessões são representadas como classes em Java. Uma mensagem que eu posso utilizar:

try{ 
  // ..
}
catch(IOExeption e) {
  System.err.println("Não foi possível ler o arquvio: " + e);
  return DEFAULT_VALUE;
}

Um código em java válido precisa honrar o requisito de Capturar ou Especificar exceções.

• OU o método captura a exceção, usando a expressão try
• OU diz explicitamente que ele pode gerar uma exceção, com a palavra chave throws

Três tipos de exceções

Exceção verificada (checked exception): são exceções relacionadas á aplicação que um código bem escrito sabe antecipar e tratar: Ex: java.io.FileNotFoundException São problemas / erros que precisamos estar preparados para lidar com eles, que fazem parte doa dia a dia.

Erro: indicam situações excepcionais externas às aplicações que normalmente não são antecipadas e nem podem ser corrigidas: Ex java.in.IOError

• É um tipo de um erro que não faz parte da execução da aplicação

Exceção de execução (runtime exception): são relacionadas à aplicação, mas que não podem ser tratadas. Normalmente indicam um bug ou uso impróprio de uma API. Ex: java.lang.NullPointerException

Observação: Exceções verificadas (checked exception) sempre devem ser capturadas ou especificadas

---

Sempre que o método poder lançar uma exceção que for verificada eu tenho que tratar!

Bloco Try

try => Tenta algo catch => captura uma exceção finally => COnjunto de instruções que eu SEMPRE QUERO que seja executado;

---

Observação sobre Catch Eu consigo em Java > 7 ter um único tratador para vários tipos de exceções.

catch (IOExpection|Exception ex){
  // Tratamento
}

Bloco finally

Ele é SEMPRE executado depois que o loco try termina.

Try-Com-Recursos

Eu consigo, se qualquer objeto que implemente a interface java.lang.AutoCloseable que pode ser usado como recurso, não precisar adicioanr catch e finally toda vez:

static String readFirstLineFromFile(String path) throws IOException{

  try (BufferedReader br = 
           new BufferedReader(new FileReader(path))){
       return r.readLine();
   }
}

É a classe BufferedReader e a classe FileReader que implementam a interface java.lang.AutoCloseable. Ou seja, o método finally está incluso / é obrigatório / passado para dentro classe que implementa essa interface. Neste caso, após implementar essa interface, a classe adiciona o método close() dentro do bloco finally. Conclusão: o método que utilizar a classe que implementa a interface java.lang.AutoCloseable ou usa o Catch ou lança uma exceção.

Obs: editor de texto preferido dele é EmEx

Exceções Encadeadas

É comum que o tratamento de uma exceção seja o lançamento de uma nova exceção A primeira exceção casa a segunda Para saber qua a causa de uma exceção, o java permite encadear as exceções com a ajuda dos seguintes métodos [pegar dos slides]

[JayCesar]

19 / 04

É importante pensar se a exceção que está sendo lançada é algo do dia a dia, ou, se é algo exceptional à aplicação. Obs: fazer / lançar uma exceção é custoso! A maneira coomo eu trato os erros depende da regra do negócio. Existem servidores de logs que onde as exceções podem estar registradas.

Handling errors effectively in Java involves more than just catching exceptions; it's about gracefully managing the exceptional conditions that can arise during the execution of your program. Inside a catch block, you can take various actions to handle errors. Here are some strategies:

1) Logging: Log the error details using a logging framework like Log4j or java.util.logging. This helps in debugging and understanding the cause of the error.

catch (Exception e) {
    logger.error("An error occurred: " + e.getMessage(), e);
}

2) Graceful Recovery: Attempt to recover from the error if possible. This might involve retrying the operation, using default values, or providing an alternative approach.

catch (SQLException e) {
    // Attempt to rollback transaction
    try {
        connection.rollback();
    } catch (SQLException rollbackException) {
        logger.error("Rollback failed: " + rollbackException.getMessage(), rollbackException);
    }
}

3) Displaying User-friendly Messages: If the error occurs in a user-facing application, present a user-friendly message explaining the problem.

catch (FileNotFoundException e) {
    System.out.println("File not found. Please provide a valid file path.");
}

4) Resource Cleanup: If the error is related to handling resources like files, database connections, or sockets, ensure proper cleanup to prevent resource leaks.

catch (IOException e) {
    // Close the input stream
    try {
        inputStream.close();
    } catch (IOException ioException) {
        logger.error("Error closing input stream: " + ioException.getMessage(), ioException);
    }
}

5) Throwing Custom Exceptions: Sometimes it's appropriate to catch an exception, perform some custom logic, and then re-throw a new exception.

catch (NumberFormatException e) {
    // Custom logic
    throw new MyCustomException("Invalid number format", e);
}

6) Notifying Administrators: For critical errors, notify administrators or support teams so they can take appropriate actions.

catch (OutOfMemoryError e) {
    // Notify administrators
    notifyAdmins("Out of memory error occurred: " + e.getMessage());
}

7) Fallback Strategies: Provide fallback strategies or alternative paths in case of error scenarios.

catch (TimeoutException e) {
    // Use a fallback method
    useFallbackMethod();
}