09 TRATAMENTO DE EXCEÇÃO

Prévia do material em texto

- -1
LINGUAGEM DE PROGRAMAÇÃO
TRATAMENTO DE EXCEÇÃO
- -2
Olá!
Ao final desta aula, você será capaz de:
1. Apresentar os conceitos de Exceção e os seus tratamentos;
2. Apresentar as estruturas de try – catch;
3. Apresentar a estrutura Throw;
4. Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos com tratamento de
exceção;
5. Explorar o conceito de tratamento de exceção em exemplos e exercícios.
1 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.
2 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 primeiro trecho de
código (na pilha de chamadas) apto a tratar a exceção lançada. O uso de exceções permite separar a detecção da
ocorrência de uma situação excepcional 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() {
- -3
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.
Saiba mais
Clique no link a seguir e saiba mais sobre o mecanismo de exceções: http://estaciodocente.
webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc01.pdf
- -4
Informando o compilador que o método poderá lançar uma ou mais exceções.
No final do cabeçalho de um método que poderá lançar exceções, coloca-se a informação:
Veremos mais adiante que para certas classes de exceção essa declaração é obrigatória, enquanto que para
outras é opcional.
3 Capturando e tratando exceções
os 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.
- -5
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.
Clique no link a seguir e veja um link completo: http://estaciodocente.webaula.com.br/cursos/gon266/docs
/09LP_doc02.pdf
4 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 {
..............
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
http://estaciodocente.webaula.com.br/cursos/gon266/docs/09LP_doc02.pdf
- -6
}
Essa cláusula é facultativa para o caso de exceções não-verificadas.
5 Construtores
A classe java.lang.Exception, e todas as suas subclasses, têm pelo menos dois construtores da forma:
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 noncheckede 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
- -7
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.
Quando o fluxo de controle chega ao comando byicatch/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 adequada' 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 comandos try externos. O bloco da cláusula finally é opcional, mas se
estiver presente será sempre executado não importando se o bloco try terminou a execução de forma normal (e
não houve bloco catou executado) ou se o bloco try terminou de forma excepcional.
- -8
O que vem na próxima aula
Na próxima aula, você estudará os seguintes assuntos:
• Tema: Manipulação de Modelo de classes em Interfaces Gráficas;
• Criar objetos baseados em classes básicas do modelo;
• Manipular os conteúdos das classes através das interfaces;
• Exercitar todos os conhecimentos adquiridos no curso.
CONCLUSÃO
Nesta aula, você:
• Identificou os conceitos de tratamentos de exceções;
• Criou e manipulou interfaces gráficas com objetos e classes efetuando o tratamento de exceções;
• Associou classes e manipulou objetos associados;
• Desenvolveu e executou pequenos programas com orientação a objetos e tratamento de exceções.
•
•
•
•
•
•
•
•
	Olá!
	1 Exceção
	2 Exceções em Java
	3 Capturando e tratando exceções
	4 Exceções verificadas e não-verificadas
	5 Construtores
	O que vem na próxima aula
	CONCLUSÃO