LINGUAGEM DE PROGRAMAÇÃO - Aula_09

Prévia do material em texto

*
*
Linguagem de Programação
EDUARDO LUIZ PARETO
Rio de Janeiro, 05 de outubro de 2011
*
Aula 9
Tratamento de Exceção
Objetivos
- Apresentar o conceitos de Exceção e os seus tratamentos
- Apresentar as estruturas de try – catch
- Apresentar a estrutura Throw
- Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos com 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 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() { 
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> 
} 
}
*
*
*
Como funciona o mecanismo de exceções 
Uma exceção em Java é um objeto da classe java.lang.Exception, ou de uma de suas subclasses. Como todo objeto, a exceção é capaz de armazenar dados nas suas variáveis de instância. Quando um erro ou situação anormal é encontrado durante a execução de um método, um objeto exceção é construído, e diversos dados sobre essa ocorrência são registrados nos campos desse objeto. Nesse momento, o método onde ocorreu a exceção aborta, e o controle da execução retorna ao método que o chamou. Além disso, por um mecanismo especial, o objeto exceção que foi construído é também enviado ao método chamador.
*
*
*
Como funciona o mecanismo de exceções 
Diz-se que o método onde ocorreu o erro "lança" a exceção para o método que o chamou. 
Suponha um método qualquer (por exemplo, main()) que chama um método g():  
public static void main (String[ ] args) { 
	...... 
	g(); 
	...... 
} 
Suponha também que, de dentro de g(), o método f() seja chamado: 
 
public void g() { 
	...... 
	f(); 
	...... 
} 
*
*
*
Como funciona o mecanismo de exceções 
Vamos admitir que no método f() podem ocorrer diversos erros ou situações excepcionais. Usando exceções, o método f() poderia ser escrito da forma abaixo. O comando throw é que se encarrega de lançar a exceção para o método chamador: 
public void f() { 
if (<teste da condição de erro A>) { 
	//constrói uma exceção da classe ExcecaoA e lança para quem chamou f() 
	throw new ExcecaoA(....lista de argumentos...); 
else if (<teste da condição de erro B>) { 
	//constrói uma exceção da classe ExcecaoB e lança para quem chamou f() 
	throw new ExcecaoB(....lista de argumentos...); 
} 
else ....<testando outros possíveis erros e procedendo de forma similar> 
	else { 
		<comandos para processar f() em condições normais sem erro> 
} 
} 
*
*
*
Como funciona o mecanismo de exceções 
Agora o método f() não precisa mais determinar o que fazer quando cada caso de erro ocorrer. Ele precisa apenas detectar que o caso de erro ocorreu. A partir daí, ele constrói, e "lança" para o método g() que o chamou, um objeto especial da classe Exception (ou de alguma subclasse). Ao construir esse objeto, o método f() insere nele as informações que permitirão entender qual erro ocorreu, e qual era o estado da aplicação no momento do erro. Esse objeto poderá ser "capturado" pelo método g(), e "tratado" lá, ou mesmo ser novamente lançado por g() para ser capturado e tratado por quem o chamou, no caso o main(). 
Vamos supor que exceções geradas por f(), do tipo ExcecaoA, devam ser capturadas e tratadas pelo método main(), e exceções do tipo ExcecaoB devam ser capturadas e tratadas no método g(). Nesse caso, os métodos main() e g() devem ser escritos da seguinte forma:
*
*
*
Como funciona o mecanismo de exceções 
public static void main (String[] args) { 
	...... 
	try{ 
		g(); 
	} 
	catch(ExcecaoA exa){ 
		....comandos para examinar a exceção referenciada por exa... 
		....comandos para tratar o erro A... 
		.................................... 
	} 
	...... 
} 
public void g() throws ExcecaoA { 
	...... 
	try{ 
		f(); 
	} 
	catch(ExcecaoB exb){ 
		....comandos para examinar a exceção referenciada por exb... 
		....comandos para tratar o erro B... 
		.................................... 
	} 
	...... 
}
*
*
*
Como funciona o mecanismo de exceções 
Note que exceções do tipo B que ocorram em f() jamais chegam a main(), pois são sempre capturadas em g(). Mas as exceções do tipo A lançadas por f() não são capturadas em g(), e são por ele re-lançadas para main(), onde são finalmente capturadas e tratadas. 
O programador tem agora mais flexibilidade para escolher em que ponto da aplicação os erros serão tratados, e de que forma. Apenas no caso de o próprio main() não capturar a exceção é que ocorrerá o encerramento anormal do programa (que irá "abortar"), sendo seguido da impressão na console de um relatório mostrando a seqüência de chamadas que originou o erro (essa seqüência é chamada de stack trace). Nos demais casos, o programa nunca aborta, mas os erros são capturados e tratados adequadamente.
*
*
*
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: 
throws <lista das classes de exceção que o método poderá lançar> 
Por exemplo: 
public void f() throws NumberFormatException, IOException{ 
	..... 
} 
Veremos mais adiante que para certas classes de exceção essa declaração é obrigatória, enquanto que para outras é opcional. 
*
*
*
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. 
*
*
*
Capturando e tratando exceções 
O bloco finally será sempre executado após o bloco try terminar normalmente, 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 casoscitados 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.
*
*
*
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.
*
*
*
Classes Notáveis
A linguagem Java tem três classes notáveis: (i)String, (ii)Object e (iii)Throwable. A classe String é a única classe que têm literais (representação de constantes). A classe Object é a única que não estende nenhuma classe em sua definição. A classe Throwable é a única classe cujas instâncias diretas ou indiretas podem ser usadas para serem lançadas. A classe Throwable é pré-definida na linguagem Java, juntamente com várias outras classes definindo um grande número de categorias de erro. 
Os programadores Java, por convenção, caso queiram criar novas exceções devem estender a classe Exception que é uma subclasse de Throwable. Duas classes descendentes da classe Throwable podem ser consideradas especiais: a classe Error e a classe RuntimeException. A linguagem Java não obriga o programador a tratar os lançamentos de exceção envolvendo instâncias da classe Error, da classe RuntimeException e das classes delas derivadas, todos os outros lançamentos de exceção devem ser tratados pelo programador.
*
*
*
Classes Notáveis
A Máquina Virtual Java lança referências para instâncias de maneira implícita utilizando as classes pré-definidas. O programador pode utilizar o comando throw de forma explícita. 
Quando o fluxo de controle atinge o comando throw <expressão>, a expressão é avaliada. Esta expressão corresponde, em geral à criação de um objeto e resulta numa referência, p. ex. throw new ErroDoTipoX();. A partir daí o fluxo de controle será desviado para uma cláusula catch apropriada de algum comando try-catch. 
O fluxo de controle segue a cadeia dinâmica dos Registros de ativação das invocações dos métodos, ou seja a execução de um método pode terminar (i) por que o fluxo de controle atingiu o final do método (return implícito, somente no caso de métodos do tipo void!), (ii) porque o fluxo de controle atingiu um comando return, ou (iii) porque foi executado um throw implícito ou explícito que não foi capturado por um comando try-catch daquele método. 
A procura por um try-catch apropriado é propagada até o ponto em que há um retorno para o método main, neste caso a execução do programa será finalizada, com mensagem de erro provida pela MVJ dizendo que uma exceção foi lançada sem que fosse apanhada.
*
*
*
Sintaxe do comando try / catch
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> 
}
*
*
*
Fim!
*
*
AULA 1
AULA 1
*
AULA 1
AULA 1
	
AULA 1
*
AULA 1