Aula13SIN1412011TratamentodeExcecao

Prévia do material em texto

Tratamento de Exceções
Prof. Marcelo Roberto Zorzan
Profa. Rachel Reis
Aula de Hoje
• Tratamento de Exceções
� Desenvolva uma aplicação Java que receba como
entrada dois valores numéricos, calcule a divisão entre eles
e exiba o resultado ao usuário.
Problema 1
Solução 1 – Problema 1
import javax.swing.JOptionPane;
public class Principal{
public static void main(String[] args){
String result, msg;
int div,num1, num2;int div,num1, num2;
result = JOptionPane.showInputDialog(null,"Digite um numero:", 
"Entrada de dados",JOptionPane.QUESTION_MESSAGE);
num1 = Integer.parseInt(result);
result = JOptionPane.showInputDialog(null,"Digite outro numero:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
num2 = Integer.parseInt(result);
div = num1/num2;
msg = String.format("Resultado da divisao: %d", div);
JOptionPane.showMessageDialog(null,msg);
}
}
� O que acontece se tentarmos dividir um número por
zero?
Erro 1 – Problema 1
Exceção lançada: ArithmeticException
� E se o usuário inserir a string “ola” como entrada
para o numerador ou denominador?
Erro 2 – Problema 1
Exceção lançada: NumberFormatException
public class Principal{
public static void main(String[] args){
String result, msg;
Solução 2 – Problema 1
String result, msg;
int div,num1, num2;
boolean continuar = true;
...
do{
try{
result = JOptionPane.showInputDialog(null,"Digite um numero:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
num1 = Integer.parseInt(result);
result = JOptionPane.showInputDialog(null,"Digite outro numero:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
num2 = Integer.parseInt(result);
div = num1/num2;
msg = String.format("Resultado da divisao: %d", div);
JOptionPane.showMessageDialog(null,msg);
continuar = false;continuar = false;
}
catch(ArithmeticException e){
System.err.println(e);
JOptionPane.showMessageDialog(null,"Erro: Divisao por zero!");
}
catch(NumberFormatException e){
System.err.println(e);
JOptionPane.showMessageDialog(null,"Erro: Entre com um valor inteiro!");
}
} while(continuar);}}
� Desenvolva uma aplicação Java que contenha um array
de inteiros de 5 posições inicializados com os seguintes
valores: {127, 34, 77, 13, 99}. O programa deve pedir ao
usuário para digitar uma posição do array e na sequência
Problema 2
usuário para digitar uma posição do array e na sequência
exibir o conteúdo da posição fornecida.
Solução 1 – Problema 2
import javax.swing.JOptionPane;
public class Principal{
public static void main(String[] args){
String result, msg;
int indice;int indice;
int array[] = {127, 34, 77, 13, 99};
result = JOptionPane.showInputDialog(null,"Digite uma posição de 0 a 4:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
indice = Integer.parseInt(result);
msg = String.format("Conteudo na posição %d: %d",indice,array[indice]);
JOptionPane.showMessageDialog(null,msg);
}
}
� O que acontece se o usuário digitar um valor menor
que 0 ou maior que 5?
Erro 1 – Problema 2
Exceção lançada: ArrayIndexOutOfBoundsException
import javax.swing.JOptionPane;
public class Principal{
public static void main(String[] args){
String result, msg;
int indice;
boolean continuar = true;
int array[] = {127, 34, 77, 13, 99};
do{
try{
result = JOptionPane.showInputDialog(null,"Digite uma posição de 0 a 4:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
Solução 2 
Problema 2
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
indice = Integer.parseInt(result);
msg = String.format("Conteudo na posição %d: %d", indice, 
array[indice]);
JOptionPane.showMessageDialog(null,msg); 
continuar = false;
}catch(ArrayIndexOutOfBoundsException e){
System.err.println(e);
JOptionPane.showMessageDialog(null,"Entre com um valor entre 0 e 4");
}
}while(continuar);
}
}
• Exceção é uma condição anormal ocorrida durante a
execução ou compilação de um programa
• O tratamento de exceções pode ser feito através de 5
Tratamento de Exceções
• O tratamento de exceções pode ser feito através de 5
palavras-chave: try, catch, throw, throws e finally;
• Quando uma “condição anormal” ocorre, dizemos que
“uma exceção será lançada“. O código responsável por
tratar essa exceção chama-se “manipulador de exceções”.
� Tipos de exceções: 
1) Exceções verificadas
2) Exceções não-verificadas
3) Erros
Tratamento de Exceções
3) Erros
� Exceções verificadas: 
• São situações de erro que o programador pode prever. 
• É possível preparar um tratamento para o problema que 
pode ocorrer. 
• Este tipo de exceção é tratado pela classe Exception.
� Exceções não-verificadas:
� Podem ocorrer em razão de erros (bugs) no programa ou 
em função de problemas complicados demais para que 
um programa possa tratá-los adequadamente. 
Tratamento de Exceções
um programa possa tratá-los adequadamente. 
� Este tipo de exceção é denominado exceção de runtime
e tratado pela classe RuntimeException.
� Erros:
� Exceções que podem ocorrer em função de problemas 
no ambiente JVM. 
� Por exemplo: falta de memória. 
� Este tipo de exceção é tratado pela classe Error.
cortar(cebola);
panela.adicionar(cebola);
Sem Tratamento de Exceção
� Dado o seguinte algoritmo:
panela.adicionar(cebola);
cortar(tomate);
panela.adicionar(tomate);
panela.adicionar(Oleo.medida(colher));
comer();
tente
{
cortar(cebola);
panela.adicionar(cebola);
cortar(tomate);
Com Tratamento de Exceção
cortar(tomate);
panela.adicionar(tomate);
panela.adicionar(Oleo.medida(colher));
}
imprevisto(CortarDedo e)
{
dedo.aplicar(curativo);
}
comer();
Capturando Exceções
• O tratamento de exceção é feito protegendo os trechos de 
código com blocos try/catch.
• Java oferece ainda os blocos finally. Com finally• Java oferece ainda os blocos finally. Com finally
garantimos que o trecho de código dentro deste bloco
sempre será executado independente de uma exceção ser
lançada ou não.
• Um bloco finally em geral contém código para:
• liberar recursos alocados no bloco try,
• fechar arquivos abertos no bloco try,
• liberar conexão com banco de dados alocados no bloco try,
• etc.
try ... catch( )
1. try {
2. // “Região Protegida“ pela palavra “try”
3. // Aqui existirá algum código que possa causar
4. // alguma exceção
5. }
6. catch (MinhaPrimeiraExceção p){
7. // Código que manipula a primeira exceção
8. }
9. catch (MinhaSegundaExceção s){
10. // Código que manipula a segunda exceção 10. // Código que manipula a segunda exceção 
11. }
• Uma vez que o controle do fluxo saltar para o bloco catch, ele não retornará
para concluir o restante do bloco try. Por exemplo, se alguma exceção do
tipo “MinhaPrimeiraExceção” ocorrer na linha 2, a execução será transferida
para a linha 7 ou 10 e, portanto, as linhas 3 e 4 não serão executadas.
• Os blocos catch devem sempre aparecer imediatamente após o bloco try.
• Todos os blocos catch precisam ficar um após o outro, sem nenhum código
entre eles.
try ... catch( ) ... finally ...
1. try {
2. // “Região Protegida“ 
3. }
4. catch (MinhaPrimeiraExceção p){
5. // Código que manipula a primeira exceção
6. }
7. finally {
8. // Código que libera recursos. Sempre será executado 
9. }
10. //Mais código10. //Mais código
• Mesmo se houver uma instrução de retorno no bloco try, o bloco finally
será executado após esta instrução. 
• O bloco finally é executado sempre ocorrendo ou não uma exceção. 
• A cláusula finally deve vir imediatamente após a última cláusula catch.
• Podemos ter um bloco try com finally, porém sem catch.
• Todo bloco try deve ter pelo menos um catch ou um finally. O bloco try 
sozinho causará erro de compilação.
try ... catch( ) ... finally ... 
try
{ 
}
finally catch()
try
{ 
}
catch()
try
{ 
}
catch()
try
{ 
}
catch()
try
{ 
}
� Possibilidades
finally
{ 
}
catch()
{ 
}
finally
{ 
}
catch()
{ 
}
catch()
{ 
}
catch()
{ 
}
catch()
{ 
}
catch()
{ 
}
catch()
{ 
}
catch()
{ 
}
finally
{ 
}
Execução sem problema
try
{ 
// Código que pode gerar uma exceção
}
catch(MinhaExcecao1 e)
{A execução começa
no início do bloco
O bloco finallyfinally é executado após catch(MinhaExcecao1 e){ 
// Código para processar a exceção 
}
catch(MinhaExcecao2 e)
{ 
// Código para processar a exceção 
}
finally
{ 
// Código que sempre será executado 
}
O bloco finallyfinally é executado após 
a execução normal do bloco trytry. 
Havendo um returnreturn, o bloco finallyfinally
sempre será executado antes da 
saída do método. 
Se não houver returnreturn no bloco trytry
nem no bloco finallyfinally, a execução 
continua com o código após o 
bloco finallyfinally
Execução com problema
try
{ 
// Código que pode gerar uma exceção
}
catch(MinhaExcecao1 e)
{ 
A execução começa
no início do bloco
A execução é interrompida no ponto
(comando) onde foi gerado a exceção. { // Código para processar a exceção 
}
catch(MinhaExcecao2 e)
{ 
// Código para processar a exceção 
}
finally
{ 
// Código que sempre será executado 
}
(comando) onde foi gerado a exceção.
O controle passa para o bloco catchcatch
que captura a exceção.
O bloco finallyfinally será executado logo
após o bloco catchcatch. 
A execução continua com o código de 
programa após o bloco finallyfinally caso 
não exista returnreturn.
Tratamento de Exceções
• Vantagens de se ter erros sinalizados por
exceções:
• separação entre o código que trata os erros e o código• separação entre o código que trata os erros e o código
que é executado normalmente pelo programa;
• é uma forma de forçar uma resposta ao erro, ou seja,
deve existir um código no programa para tratar o erro;
• permite que o mesmo código de manipulação de
exceções lide com as diferentes exceções possíveis.
Tratamento de Exceções
� A classe java.lang.Exception é a classe base para 
tratamento de exceções verificadas.
� Diversas subclasses da classe Exception são definidas na 
API para fazer o tratamento de exceções específicas.API para fazer o tratamento de exceções específicas.
� A classe java.lang.Exception é uma subclasse da classe 
java.lang.Throwable.
� Os únicos métodos da classe java.lang.Exception são 
seus construtores:
� Exception() que constrói um objeto padrão 
� Exception(String s) que constrói um objeto com uma mensagem 
de erro específica.
Tratamento de Exceções
� Um tipo de exceção refere-se às subclasses da classe 
Exception. 
� Exemplo:
� ClassNotFoundException � DataFormatException
� IOException � PrintException
� RuntimeException
� Se o bloco catch especificar um determinado tipo de exceção,
somente exceções deste tipo serão capturadas.
� Caso um objeto Exception seja definido no bloco catch
qualquer tipo de exceção será capturada.
import javax.swing.JOptionPane;
public class Principal{
public static void main(String[] args){
String result, msg;
int indice;
boolean continuar = true;
int array[] = {127, 34, 77, 13, 99};
do{
try{
result = JOptionPane.showInputDialog(null,"Digite uma posição de 0 a 4:",
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
Altere o tipo de exceção para 
Exception. O que ocorre? Por quê?
Altere o tipo de exceção para 
ArithmeticException. O que 
ocorre? Por quê?
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
indice = Integer.parseInt(result);
msg = String.format("Conteúdo na posição %d: %d", indice, 
array[indice]);
JOptionPane.showMessageDialog(null,msg); 
continuar = false;
}catch(ArrayIndexOutOfBoundsException e){
System.err.println(e);
JOptionPane.showMessageDialog(null,"Entre com um valor entre 0 e 4");
}
}while(continuar);
}
}
import javax.swing.JOptionPane;
public class Principal{
public static void main(String[] args){
String result, msg;
int indice;
boolean continuar = true;
int array[] = {127, 34, 77, 13, 99};
do{
try{
result = JOptionPane.showInputDialog(null,"Digite uma posição de 0 a 4:", 
"Entrada de dados", JOptionPane.QUESTION_MESSAGE);
indice = Integer.parseInt(result);
O que vai ocorrer neste 
caso?
indice = Integer.parseInt(result);
msg = String.format("Conteudo na posicao %d: %d", indice, array[indice]);
JOptionPane.showMessageDialog(null,msg); 
continuar = false;
} catch(Exception e){
System.err.println(e);
JOptionPane.showMessageDialog(null, "Erro");
}catch(ArrayIndexOutOfBoundsException e){
System.err.println(e);
JOptionPane.showMessageDialog(null,"Entre com um valor entre 0 e 4");
}
}while(continuar);
}
}
Hierarquia de Exceções
• Todas as classes de exceção herdam, direta ou
indiretamente, da classe Exception.
• A classe Throwable (subclasse de Object) é a super• A classe Throwable (subclasse de Object) é a super
classe de Exception.
• Somente objetos Throwable podem ser utilizados com o
mecanismo de tratamento de exceções
Parte da Hierarquia de Exceções
Mais informações em: http://download.oracle.com/javase/6/docs/api/
ThrowableErros internos e exaustão de 
recursos dentro do Java Runtime. 
Ex: estouro de memória
Hierarquia de Exceções
Error Exception
IOException RuntimeException
Acesso a uma posição que 
não existente de um array;
Acesso a um ponteiro null.
Tentar ler além do final de um arquivo;
Tentar abrir uma URL mal construída
Cláusula throws 
Propagando uma exceção
• Se a exceção não é tratada pelo método onde ela 
ocorreu, ou seja, se não existe uma cláusula catch para 
esta exceção, então ocorre a “propagação da exceção”.
• “Propagar uma exceção” significa que algum método da 
pilha de chamadas irá tratar a exceção ou continuará a 
propagá-la, até que o aplicativo pare de ser executado.
• Cláusula throws: usada no cabeçalho de um método 
para indicar que ele propaga a exceção (não o trata)
public class Teste{
public static void main (String[] args){ 
metodoA(); 
} 
public static void metodoA(){ 
metodoB(); 
Cláusula throws
metodoB(); 
} 
public static void metodoB(){ 
int divisao = 2/0; 
// ArithmeticException
}
}
java.lang.ArithmeticException: / by zero
at Exceptions.Teste.metodoB(Teste.java:12)
at Exceptions.Teste.metodoA(Teste.java:9)
at Exceptions.Teste.main(Teste.java:5)Exception in thread "main"
Cláusula Throws
• No exemplo anterior vemos a pilha de chamadas enquanto
o metodoB() está sendo executado.
• O métodoB() não tratou a exceção (ArithmeticException),• O métodoB() não tratou a exceção (ArithmeticException),
apenas passou a responsabilidade para o metodoA() e
este passou para main() até que houve uma interrupção da
máquina virtual Java.
• As exceções lançadas por um método, quando não
tratadas no próprio método via try/catch, devem sempre
ser declaradas na assinatura do método.
Cláusula Throws
• A palavra chave throws é usada para listar as exceções 
que um método pode lançar. 
• Dessa forma, a assinatura do métodoB() seria: 
public static void metodoB() throws ArithmeticException
{ 
... 
}.
public class Teste{
public static void main(String[] args){
try {
metodoA();
}catch(ArithmeticException a) {
Solução para a classe Teste
}catch(ArithmeticException a) {
System.out.println("Erro");
} 
} 
public static void metodoA() throws ArithmeticException{ 
metodoB();
} 
public static void metodoB() throws ArithmeticException{ 
int divisao = 2/0; 
} 
}
throw X throws - Exemplo
• Para forçar a ocorrência de uma exceção, utiliza-se a 
palavra reservada throw (no singular)
public void metodo1( ) {
try {try {
metodo2( );
} catch (IOException e) { 
System.err.println(e); }
}
public void metodo2( ) throws IOException {
if (…problema…)
throw new IOException( );
}
throws (plural)
propaga exceção
Cláusula throw
Lançando uma exceção
public static void main(String[] args) { 
try{ 
divisao(5.0, 0.0);
} catch(Exception e){
System.err.println(e);
Exemplo
System.err.println(e);
}
}
public static double divisao(double n, double d) throws Exception{ 
if (d == 0.0){ 
throw new Exception(“denominador não pode ser zero");
} else
return (n / d);
}
throw - Exemplo
public double divisao(double n, double d) 
throws ArithmeticException{ 
if (d == 0.0){ 
throw new ArithmeticException(" ");thrownew ArithmeticException("denominador não pode ser zero");
} else
return (n / d);
}
• Como a java.lang.ArithmeticException herda de 
RuntimeException ela não precisa ser tratada, mas 
se o erro ocorrer a mensagem aparecerá para o usuário 
Tratamento de Exceções
procedimentos
1 3
throw
(indica ocorrência)
catch
(captura e trata)
throws
(propaga)
2
Exemplo 1 - Revisando
public void teste(){ 
double r = 0.0;
try{ 
r = 3.0/0.0; r = 3.0/0.0; 
}catch(Exception e){ 
System.out.println(e); 
}
System.out.println(“A divisão é ”+r);
}
� Uma exceção tem que ser tratada ou então passada 
adiante! [aqui o tratamento ocorre através de try/catch]
Exemplo 2 - Revisando
public void teste() throws Exception
{ 
double r;
r = 3.0/0.0;r = 3.0/0.0;
System.out.println(“A divisão é ”+r);
}
� Uma exceção pode ser passada adiante até gerar um erro 
de execução [aqui a exceção está sendo passada adiante, 
através do uso da cláusula throws].
Tratamento de Exceções
� Instruções para criar suas próprias exceções:
� A nova classe de exceção deve estender uma classe
de exceção existente.
� A classe de exceção pode conter campos e métodos.� A classe de exceção pode conter campos e métodos.
� A nova classe de exceção deve conter somente dois
construtores:
- Um que não aceita nenhum argumento
- Um que passe uma mensagem de exceção padrão para o
construtor da superclasse.
� Por convenção todos os nomes de classe de exceções
devem terminar com a palavra Exception.
Tratamento de Exceções
� Criando suas próprias exceções
1) A classe tratadora de exceção é uma subclasse da classe 
Exception.
public class NovaExcecaoException extends Exception {public class NovaExcecaoException extends Exception {
private int valor;
public NovaExcecaoException(){}
public NovaExcecaoException(int v){
valor = v;
}
public String toString(){
return "Nova exceção " + valor;
}
}
public static void main(String[] args) { 
try{ 
metodoA();
Tratamento de Exceções
� Chamando a sua exceção no código
Saída:
Nova Exceção 2metodoA();
} catch(NovaExcecaoException e){
System.err.println(e);
}
}
public static void metodoA() throws NovaExcecaoException{ 
throw new NovaExcecaoException(2);
}