Tratamento de Exceção em Java

Prévia do material em texto

Aula 9
 Tratamento de Exceção
Exceção
Uma exceção é uma ocorrência que altera o fluxo normal da execução de um programa. Esta ocorrência deve ser tratada para evitar que o programa encerre seu funcionamento. 
Existem diversos tipos de exceção. Erro na entrada de dados, erro na conexão com o banco de dados, erro na leitura de arquivos, erro de uma operação matemática. Sempre que o computador executa um código que gera uma exceção, ou o Sistema Operacional irá terminar seu programa ou o seu programa deverá fazer o tratamento para esta exceção.
Um método pode detectar uma falha, mas não estar apto a resolver sua causa, devendo repassar essa função a quem saiba. Se o tratamento de falhas for introduzido ao longo do fluxo normal de código, pode-se estar comprometendo muito a inteligibilidade do código.
Exceções em Java
Diz-se que uma exceção é lançada para sinalizar alguma falha. O lançamento de uma exceção causa uma interrupção abrupta do trecho de código que a gerou. O controle da execução volta para o seu primeiro trecho de código ( na pilha de chamadas) apto a tratar a exceção lançada.
O uso de exceção permite separar a detecção da ocorrência de uma situação do seu tratamento, ao se programar um método em Java. Na forma antiga de se programar, era comum embutir as ações a tomar em cada teste de erro.
Por exemplo, uma função hipotética f() ficava assim:
void f() { 
if (<teste da condição de erro 1>) { 
<comandos que determinam o que fazer se o erro 1 ocorreu> 
} 
else if (<teste da condição de erro 2>) { 
<comandos que determinam o que fazer se o erro 2 ocorreu> 
} 
else ....<testando e tratando outros possíveis erros> 
else { 
<comandos para processar a função em condições normais> 
} 
}
Esta forma de programar prejudica o bom design das aplicações. Se um método for usado em aplicações diferentes, o mesmo erro sempre será tratado da mesma maneira. Isso limita a flexibilidade de lidar com situações de exceção. Se for necessário alterar o procedimento a seguir no caso de um determinado erro, o método na forma acima terá que ser alterado. Isso introduz riscos e obrigará a re-testar todo o método, inclusive as partes que já estavam funcionando corretamente.
No final do cabeçalho de um método que poderá lançar exceções, coloca-se a informação:
throws <lista das classes de exceção que o método
poderá lançar>
Por exemplo:
Public void f() throws NumberFormatException,
IOExpection{
......
}
Capturando e tratando exceçõesos blocos try { }, catch(){ }, e finally { }
Quando programamos um método em Java, e dentro desse método existem comandos ou chamadas de métodos onde podem ocorrer uma ou mais exceções, os comandos devem ser colocados dentro de um bloco try, que tem a forma:
try { 
<comandos> 
}
No caso de ocorrer uma exceção no bloco try, ela será lançada, os demais comandos do bloco serão suspensos, e o controle passará para o primeiro bloco catch que tenha um parâmetro de tipo compatível com a exceção lançada. Pode haver zero, um ou mais blocos catch após um bloco try. Os blocos catch e finally são opcionais, mas não é permitido haver apenas o bloco try sem pelo menos um bloco catch ou um bloco finally associado. 
O bloco finally será sempre executado após o bloco try terminar normalmete, ou após os blocos catch executarem, mesmo que a saída desses blocos seja causada pelo lançamento de outra exceção não tratada, ou por comando return. O bloco finally somente não será executado se ocorrer uma chamada para terminar a JVM, com System.exit(0).
Comandos após o bloco finally serão executados se não houver os casos citados acima. Tipicamente, o bloco finally conterá comandos de liberação de recursos alocados no bloco try (abertura de arquivos, de banco de dados, etc). Se esses comandos ficassem no final do bloco try, poderiam nunca ser executados em caso de lançamento de exceção.
Por exemplo:public void g() { 
try{ 
f(); 
} 
catch (NumberFormatException nfe){ 
<comandos para tratar a exceção> 
} 
catch (Exception e){ 
<comandos para tratar a exceção> 
} 
} 
	
Suponha que ao executar, o método f() lance uma exceção do tipo NumberFormatException. Ela será capturada pelo primeiro bloco catch acima. Se lançar outro tipo de exceção, ela será capturada pelo segundo bloco catch.
Exceções verificadas e não-verificadas:
A linguagem Java admite dois tipos de exceção: As não verificadas (unchecked, em inglês) são instâncias de subclasses de RuntimeException. O compilador não verifica se existe possibilidade de serem lançadas, e não exige que os métodos onde possam ocorrer façam qualquer tratamento. Elas representam erros ou defeitos na lógica do programa que podem causar problemas irrecuperáveis em tempo de execução (run time). 
Por outro lado, instâncias de Exception, ou de qualquer outra de suas subclasses, são verificadas (checked) como, p.ex, IOException, ClassNotFoundException e CloneNotSupportedException. Elas representam erros que podem ocorrer em tempo de execução, mas que não dependem da lógica do programa, em geral defeitos nos dispositivos de entrada ou saída (arquivos, rede, etc).
O compilador exige que um método onde possam ocorrer exceções verificadas faça uma de duas coisas: ou utilize blocos try-catch-finally para capturar e tratar essas exceções, ou declare que pode lançar essas exceções para o método chamador, colocando uma cláusula "throws" no seu cabeçalho, como por exemplo: 
 
public void M() throws IOException, CloneNotSupportedException { 
.............. 
} 
 
Essa cláusula é facultativa para o caso de exceções não-verificadas.
Construtores
A classe java.lang.Exception, e todas as suas subclasses, têm pelo menos dois construtores da forma:
<nome da classe de Exceção> ()
<nome da classe de Exceção> (String <mensagem de erro>)
A mensagem de erro é sempre retornada pelo método toString(). Toda exceção também aceita a mensagem printStackTrace(), que imprime na stream apontada por System.err um stack trace. O stack trace é um relatório detalhado da seqüência de chamadas a métodos que antecederam o lançamento da exceção.
Para lançar uma exceção que seja instância das classes de verificação obrigatória a linguagem obriga o programador a declarar no cabeçalho do método quais as classes de exceção podem ter instâncias lançadas. Portanto, o formato completo do cabeçalho de definição de um método é:
<modificadores> <tipo> <nome>(<parametros>) throws <classes> 
static void m() throws ErroDoTipoX, ErroDoTipoY, ErroDoTipoZ{ .
 .. 
throw new ErroDoTipoX();
 ... 
throw new ErroDoTipoY();
 ... 
throw new ErroDoTipoZ(); 
}
Se o programador quiser estender a classe que contém o método m() da tela anterior e se o programador quiser sobrepor o método m() então o novo método terá de declarar o lançamento de instâncias das mesmas classes. Isso garante que um código que trabalha com a classe base trabalhará também com as classes derivadas. 
A figura abaixo ilustra o relacionamento entre as exceções checked e nonchecked e a hierarquia de classes com raiz na classe Throwable. Os retângulos com nomes representam classes e os triângulos representam hierarquias de classes com classe “raiz” identificada pelo retângulo da ponta superior do triângulo. Na hierarquia de classes predefinida em Java a classe Throwable tem somente duas classes filhas (Error e Exception), mas um programador Java pode definir outras hierarquias a partir da Throwable (embora isso não seja recomendável).
As classes e hierarquias cujo lançamento de instâncias seja de verificação obrigatória são identificadas na cor cinza.Todas as instâncias diretas e indiretas da classe Error e da classe RuntimeException são de verificação opcional. Todas as instâncias diretas e indiretas da classe Throwable, que não sejam as instâncias diretas e indiretas das classes Error e RuntimeException, são de verificação obrigatória.
A sintaxe básica do comando try/catch (na verdade try/catch/finally!): 
try{ 
<comandos que podem ou não lançar exceções> 
} catch(ExcecaoTipo1 parâmetro){ 
<tratamento da instância da classe ExcecaoTipo1> 
}catch(ExcecaoTipo2 parâmetro){ 
<tratamento da instância da classe ExcecaoTipo2> 
} ... 
} finally{ 
<estes comandos serão executados com ou sem lançamento de exceção> 
}
Quando o fluxo de controle chega ao comando try/catch/ finally o fluxo de controle passa a percorrer o bloco try. Se uma instância de classe de exceção é lançada cada cláusula catch, é examinada e o parâmetro da cláusula catch “mais adequado” recebe a referência da instância lançada e o fluxo de controle passa a percorrer o bloco da cláusula catch. Nenhuma outra cláusula catch é executada! Se nenhuma cláusula catch for adequada o lançamento da exceção será verificado por comando try externos. O bloco da cláusula finally é opcional, mas se estiver presente será sempre executando não importando se o bloco try terminou a execução da forma normal (e não houve bloco catch executado) ou se o bloco try terminou de forma excepcional.