Tratamento de Exceções. Prof. Marcelo Roberto Zorzan

Transcrição

1 Tratamento de Exceções Prof. Marcelo Roberto Zorzan

2 Tratamento de Exceções Aula de Hoje

3 Problema 1 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.

4 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; 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);

5 Erro 1 Problema 1 O que acontece se tentarmos dividir um número por zero? Exceção lançada: ArithmeticException

6 Erro 2 Problema 1 E se o usuário inserir a string ola como entrada para o numerador ou denominador? Exceção lançada: NumberFormatException

7 Solução 2 Problema 1 public class Principal public static void main(string[] args) String result, msg; int div,num1, num2; boolean continuar = true;...

8 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; 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);

9 Problema 2 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 exibir o conteúdo da posição fornecida.

10 Solução 1 Problema 2 import javax.swing.joptionpane; public class Principal public static void main(string[] args) String result, msg; 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);

11 Erro 1 Problema 2 O que acontece se o usuário digitar um valor menor que 0 ou maior que 5? Exceção lançada: ArrayIndexOutOfBoundsException

12 import javax.swing.joptionpane; public class Principal public static void main(string[] args) Solução 2 Problema 2 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); 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);

13 Tratamento de Exceções 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 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.

14 Tratamento de Exceções Tipos de exceções: 1) Exceções verificadas 2) Exceções não-verificadas 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.

15 Tratamento de Exceções 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. 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.

16 Sem Tratamento de Exceção Dado o seguinte algoritmo: cortar(cebola); panela.adicionar(cebola); cortar(tomate); panela.adicionar(tomate); panela.adicionar(oleo.medida(colher)); comer();

17 Com Tratamento de Exceção tente cortar(cebola); panela.adicionar(cebola); cortar(tomate); panela.adicionar(tomate); panela.adicionar(oleo.medida(colher)); imprevisto(cortardedo e) dedo.aplicar(curativo); comer();

18 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 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.

19 try... catch( ) 1. try 2. // Região Protegida pela palavra try 3. // Aqui existirá algum código que possa causar 4. // alguma exceção catch (MinhaPrimeiraExceção p) 7. // Código que manipula a primeira exceção catch (MinhaSegundaExceção s) 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.

20 try... catch( )... finally try 2. // Região Protegida catch (MinhaPrimeiraExceção p) 5. // Código que manipula a primeira exceção finally 8. // Código que libera recursos. Sempre será executado //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.

21 try... catch( )... finally... Possibilidades try finally try catch() try catch() finally try catch() catch() try catch() catch() catch() catch() finally

22 Execução sem problema A execução começa no início do bloco O bloco finally é executado após a execução normal do bloco try. Havendo um return, o bloco finally sempre será executado antes da saída do método. Se não houver return no bloco try nem no bloco finally, a execução continua com o código após o bloco finally try // Código que pode gerar uma exceção 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

23 Execução com problema A execução começa no início do bloco A execução é interrompida no ponto (comando) onde foi gerado a exceção. O controle passa para o bloco catch que captura a exceção. O bloco finally será executado logo após o bloco catch. A execução continua com o código de programa após o bloco finally caso não exista return. try // Código que pode gerar uma exceção 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

24 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 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.

25 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. 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.

26 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.

27 import javax.swing.joptionpane; public class Principal public static void main(string[] args) Altere o tipo de exceção para Exception. O que ocorre? Por quê? String result, msg; int indice; boolean continuar = true; int array[] = 127, 34, 77, 13, 99; do try Altere o tipo de exceção para ArithmeticException. O que ocorre? Por quê? 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("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);

28 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 O que vai ocorrer neste caso? 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 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);

29 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 classe de Exception. Somente objetos Throwable podem ser utilizados com o mecanismo de tratamento de exceções

30 Parte da Hierarquia de Exceções Mais informações em:

31 Hierarquia de Exceções Erros internos e exaustão de recursos dentro do Java Runtime. Ex: estouro de memória Throwable Error Exception 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 IOException RuntimeException

32 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)

33 Cláusula throws public class Teste public static void main (String[] args) metodoa(); public static void metodoa() 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"

34 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), 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.

35 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....

36 Solução para a classe Teste public class Teste public static void main(string[] args) try metodoa(); catch(arithmeticexception a) System.out.println("Erro"); public static void metodoa() throws ArithmeticException metodob(); public static void metodob() throws ArithmeticException int divisao = 2/0;

37 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 metodo2( ); catch (IOException e) System.err.println(e); throws (plural) propaga exceção public void metodo2( ) throws IOException if ( problema ) throw new IOException( );

38 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 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);

39 throw - Exemplo public double divisao(double n, double d) throws ArithmeticException if (d == 0.0) throw new 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

40 Tratamento de Exceções procedimentos 1 throw (indica ocorrência) 3 catch (captura e trata) 2 throws (propaga)

41 Exemplo 1 - Revisando public void teste() double r = 0.0; try 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]

42 Exemplo 2 - Revisando public void teste() throws Exception double r; 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].

43 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 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.

44 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 private int valor; public NovaExcecaoException() public NovaExcecaoException(int v) valor = v; public String tostring() return "Nova excec ão " + valor;

45 Tratamento de Exceções Chamando a sua exceção no código public static void main(string[] args) try metodoa(); catch(novaexcecaoexception e) System.err.println(e); Saída: Nova Exceção 2 public static void metodoa() throws NovaExcecaoException throw new NovaExcecaoException(2);