Tratamento de exceções em Java

Hoje vou falar um pouquinho sobre o tratamento de exceções em Java, tambem do porque usar, sua estrutura e o que é uma exceção.

Como é comum no estudo do Java, ao chegar nesta parte e não conseguir visualizar a utilidade desse recurso e confundir os resultados com as instruções condicionais.

Conceito de Exceção

Exceção representa uma situação não esperada ocorrida na execução de algum trecho de programa.

Uma exceção deve ser vista como um retorno alternativo da execução de algum método.

O processo de gerar uma exceção é chamado de “lançamento de exceção” e o processo de processar uma exceção é chamado de “capturar a exceção”.

A exceção pode ser capturada por uma função dentro da seqüência de funções chamadas.

Agora veremos abaixo a estrutura de como tratar um erro ou exceção:

try - é usada para indicar um bloco de código que possa ocorrer uma exceção.

catch – serve para manipular as exceções, ou seja, tratar o erro

finally – sempre será executado depois do bloco try/catch. O importante é saber que esse bloco sempre será executado (exceto nos casos de encerramento da jvm System.exit()).

Veja abaixo as combinações válidas e inválidas para o uso do try{}, cacth{} e finally{} (isso é questão de certificação).

Combinações válidas:

try{}	catch{}
try{}	finally{}
try{}	catch{}	finally{}

Inválidas não Compila:

try{}	—	–
catch{}	finally{}	—
try{}	finally{}	catch{}

Tipos de Exceções em Java

Existem três tipos básicos de exceção em Java

Error

São exceções lançadas internamente pela Máquina Virtual na ocorrência de algum tipo de erro interno ou de falta de algum recurso.

Não se deve lançar nem tratar exceções desse tipo.

RuntimeException

São exceções lançadas devido algum erro do programa, como por exemplo, cast inválido, índice fora dos limites, acesso a referência nula de alguma classe.

Outras Exceções

São as exceções criadas para representar diversas situações. Podem ser as exceções criadas pelas bibliotecas ou exceções criadas pelo usuário.

Documentando as Exceções

A linguagem Java irá obrigar o programador a definir uma lista de exceções no cabeçalho do método quando ocorrer algumas das seguintes situações.

O método chama algum outro método que também possui em seu cabeçalho a indicação de lançamento de exceção e não faz o tratamento dessa exceção. O método lança uma exceção e não trata a mesma.

Sintaxe:

tipo_de_retorno nome ([params]) throws NomeExceção { ….. }

Capturando uma Exceção

Para capturar uma exceção devemos colocar o código passível de lançamento de exceção dentro de um bloco try. Para capturar a exceção devemos usar o catch.

Sintaxe:

try {

…. –> Código que pode lançar uma exceção

}

catch (tipo_exc e){

…. –> Código de tratamento

}

Lançando uma Exceção

Para lançar uma exceção deve-se usar o comando throw seguido de uma referência de uma classe de exceção.

Essa referência deve ter uma instância da classe de exceção a ser lançada.

Sintaxe:

retorno_do_método nome ([params]) throws

NomeExceção {

…..

if (cond_erro)

throw new IOException ();

….

}

Criando uma Classe de Exceção

Para criar uma nova classe de exceção de aplicação deve-se:

• Criar a classe herdando de alguma outra exceção existente ou da classe Exception.
• Criar um construtor sem parâmetros e um com um parâmetro do tipo String.
• No construtor do tipo String chamar o construtor da classe base, usando super, passando a string recebida.
• Podem-se colocar atributos e métodos adicionais na classe para definição melhor da exceção.

Métodos da Classe Throwable

A classe Throwable, classe base de todas as exceções do Java, possui os seguintes métodos:

• String getMessage( );

Retorna a descrição usada na criação da exceção.

• String toString( );

Retorna a descrição curta da exceção (nome/msg).

• void printStackTrace( );

Mostra todas as informações da pilha no momento da exceção.

• Throwable fillInStackTrace( );

Recoloca as informações na pilha da exceção.

Relançando uma Exceção

Uma vez capturada uma exceção, ela termina a função de indicar algum erro. Caso seja necessário que o tratamento continue em níveis superiores deve-se relançar a mesma através do comando throw colocado dentro do bloco catch.

O relançamento de uma exceção difere do lançamento no sentido de que não é criada uma nova instância e sim lançada a mesma instância da exceção capturada.

Sintaxe:

catch (tipo_exc e){

…. –> Código de tratamento

throw e; –> Relançando

}

Bloco finally

O bloco finally serve para indicar o código que será sempre executado em uma estrutura try…catch independente do caminho realizado por uma execução, normal ou exceção.

O bloco deve ser colocado após os blocos catch.

Pode-se colocar uma estrutura try com um bloco finnaly somente, sem o bloco catch.

Sintaxe:

finally {

…. –> Código a ser executado sempre

}

Exceções predefinidas do JAVA

Dentro do pacote-padrão java.lang Java define várias classes de exceção.  A maioria destas exceções são subclasses do tipo padrão RuntimeException. Desde que java.lang é implicitamente importada para todos os programas Java, a maioria das exceções derivadas de RuntimeException estão automaticamente disponíveis.

Então quando Usar Exceções !

Algumas sugestões sobre o uso de exceções:

• Não utilize exceções no lugar de testes simples. O tratamento de uma exceção custa muito em termos de processamento.
• Não faça o gerenciamento detalhado de exceção colocando cada comando que pode lançar uma exceção dentro de um bloco try/catch.
• Não descarte uma exceção, ou seja, não coloque um bloco catch vazio somente para evitar o erro de compilação.
• Não sinta constrangimento em não tratar todas as exceções que o seu código lançou. Trate somente as exceções cujo contorno você conhece.