Baixe o app para aproveitar ainda mais
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); }
Compartilhar