17.7 Tratamento de Exceções e a Hierarquia de Exceções em Java
O tratamento de exceções é um aspecto fundamental na programação Java, pois permite que um programa reaja adequadamente a condições inesperadas durante a execução. Exceções em Java são objetos que representam situações anormais que podem ocorrer durante a execução de um programa. Ao entender a hierarquia de exceções e aprender a manipulá-las corretamente, os programadores podem criar aplicações mais robustas e confiáveis.
Hierarquia de Exceções em Java
Em Java, todas as exceções são descendentes da classe Throwable. Esta classe é dividida em duas subclasses principais: Error e Exception. A classe Error é usada para situações de erros graves que a aplicação normalmente não deve tentar tratar, como problemas na máquina virtual Java (JVM). Já a classe Exception é a que nos interessa para o tratamento de exceções, pois ela inclui todas as exceções que uma aplicação pode querer tratar.
As exceções da classe Exception são divididas em duas categorias: exceções verificadas (checked exceptions) e não verificadas (unchecked exceptions). As exceções verificadas são aquelas que o compilador exige que sejam tratadas ou declaradas na assinatura do método. Exemplos incluem IOException e SQLException. Já as não verificadas, subclasse de RuntimeException, não precisam ser explicitamente tratadas ou declaradas. Exemplos comuns são NullPointerException e IndexOutOfBoundsException.
Métodos e a Cláusula throws
Quando um método pode lançar uma exceção que ele mesmo não trata, ele deve declarar esta possibilidade usando a cláusula throws em sua assinatura. Isso é obrigatório para exceções verificadas, mas opcional para exceções não verificadas. A cláusula throws informa ao chamador do método que ele deve estar preparado para tratar essa exceção ou, alternativamente, propagá-la.
public void meuMetodo() throws IOException {
// Código que pode lançar uma IOException
}
Se o método meuMetodo acima lançar uma IOException, ele não precisa tratar essa exceção internamente; em vez disso, ele a propaga para o método que o chamou. Esse método chamador então precisa tratar a exceção ou também declará-la em sua assinatura com a cláusula throws.
- Ouça o áudio com a tela desligada
- Ganhe Certificado após a conclusão
- + de 5000 cursos para você explorar!
Baixar o aplicativo
Tratando Exceções com try-catch
Para tratar exceções, usamos os blocos try e catch. O bloco try contém o código que pode lançar uma exceção, enquanto o bloco catch contém o código que é executado se uma exceção ocorrer. Podemos ter vários blocos catch para tratar diferentes tipos de exceções.
try {
// Código que pode lançar exceções
} catch (IOException e) {
// Código para tratar IOException
} catch (SQLException e) {
// Código para tratar SQLException
}
É importante notar que os blocos catch devem seguir a ordem de especificidade, do mais específico para o mais genérico, pois uma vez que uma exceção é capturada por um bloco catch, os blocos subsequentes não são avaliados.
Cláusula finally
Existe também a cláusula finally, que é opcional e segue os blocos try-catch. O código dentro do bloco finally é executado independentemente de uma exceção ser lançada ou não, sendo útil para a execução de código de limpeza, como fechar conexões ou liberar recursos.
try {
// Código que pode lançar exceções
} catch (Exception e) {
// Código para tratar exceções
} finally {
// Código executado sempre após o try ou catch
}
Propagação de Exceções
Às vezes, pode ser desejável ou necessário propagar uma exceção para que seja tratada em outro lugar. Isso é feito simplesmente não capturando a exceção em um bloco catch ou lançando-a novamente dentro de um bloco catch usando a palavra-chave throw.
public void meuMetodo() throws IOException {
try {
// Código que pode lançar uma IOException
} catch (IOException e) {
// Pode-se fazer algo com a exceção e lançá-la novamente
throw e;
}
}
Exceções Personalizadas
Os desenvolvedores também podem criar suas próprias exceções personalizadas estendendo a classe Exception (para exceções verificadas) ou RuntimeException (para exceções não verificadas). Isso é útil quando você deseja criar exceções específicas para os casos de uso do seu aplicativo.
public class MinhaExcecao extends Exception {
public MinhaExcecao(String mensagem) {
super(mensagem);
}
}
Em resumo, o tratamento de exceções em Java é uma ferramenta poderosa para criar programas robustos e confiáveis. Ao entender a hierarquia de exceções e saber como declarar, lançar e tratar exceções, você pode garantir que seu programa lide com situações inesperadas de maneira controlada.
