Seminário: Manipulação de exceções em Java Fabiana Piesigilli Rodrigo Mendes Leme MAC 441 - Programação Orientada a Objetos.

Apresentação em tema: "Seminário: Manipulação de exceções em Java Fabiana Piesigilli Rodrigo Mendes Leme MAC 441 - Programação Orientada a Objetos."— Transcrição da apresentação:

1 Seminário: Manipulação de exceções em Java Fabiana Piesigilli Rodrigo Mendes Leme MAC 441 - Programação Orientada a Objetos

2 Introdução

3  Mundo ideal: dados estão sempre na forma certa, arquivos desejados sempre existem, etc.  Mundo real: dados ruins e bugs podem arruinar o programa. Introdução

4  Necessidade de mecanismos para tratamento de erros.  Antes da POO: Variável global inteira com valores de 0 até n. Na ocorrência de uma exceção: Variável assumia um valor. Remetia uma mensagem de erro. Encerrava o programa. Introdução

5  Depois da POO: Classes de erros. Possíveis tipos de erros e seus tratamentos são agrupados. Não há necessidade de interromper o programa. O mesmo erro é tratado quantas vezes for necessário. Introdução

6  Idéia básica: “código ruim não será executado”.  Nem todos os erros podem ser detalhados em tempo de compilação.  Os que não podem devem ser lidados em tempo de execução.  Estes últimos são o alvo da manipulação de exceções. Introdução

7  Premissa básica: separar o processamento normal da manipulação de erros.  Vantagens desse mecanismo: Permite concentrar em lugares diferentes o “código normal” do tratamento do erro. Simplifica a criação de programas grandes usando menos código. Torna o código mais robusto, ao garantir que não há erros sem tratamento. Introdução

8 Exceções - básico

9 Hierarquia de exceções de Java ErrorException Throwable IOExceptionRunTimeException...

10  Exceção: problema que impede a continuação do método ou escopo em execução.  Importante: exceção  problema normal.  Problema normal: há informação suficiente no contexto atual para lidar com ele.  Exceção: não há informação suficiente.  Disparar uma exceção: sair do contexto atual e relegar a solução a um contexto mais abrangente.

11  Ao disparar-se uma exceção, ocorre a seguinte sequência de eventos: Um objeto exceção é criado. A execução é interrompida. O mecanismo de manipulação de exceções assume o controle o procura o manipulador de exceção adequado. O manipulador da exceção trata o problema. Exceções: Básico

12  Exemplo: seja t uma referência para um objeto, que pode não ter sido inicializado. if (t == null) throw new NullPointerException();  A palavra chave throw dispara uma exceção e dá início à sequência de eventos citada anteriormente.

13  Outra versão: if (t == null) throw new NullPointerException (“t = null”);  Este construtor permite colocar informações pertinentes na exceção, que posteriormente podem ser extraídas usando outros métodos.

14  Em resumo, disparar uma exceção é fácil: 1) Escolha uma classe de exceção apropriada. 2) Instancie um objeto dessa classe. 3) Dispare-o. throw new EOFException(); (1)(2)(3)

15 Capturando exceções

16  Quando uma exceção é disparada, em algum lugar ela deve ser capturada.  Região protegida: trecho de código que pode gerar exceções.  Manipuladores de exceções: tratam as exceções que ocorreram dentro da região protegida. Vêm imediatamente após a mesma. Capturando exceções

17  Em Java: try : indica a região protegida. catch : manipula uma exceção. Formato básico: try { // Código } catch(ClasseDeExceção e) { // Manipula aquele tipo de erro }

18  Pode-se usar vários manipuladores: try {... } catch(ClasseDeExcecao1 c1) {... } catch(ClasseDeExcecao2 c2) {... } catch(ClasseDeExcecao3 c3) {... }...

19  Processo:  A exceção é disparada dentro de um bloco try.  O mecanismo de manipulação de exceção procura o primeiro catch cujo tipo de exceção bata com a exceção disparada.  O mecanismo entra no bloco do catch e o erro é tratado. Capturando exceções

20  Exemplo: método para ler caracteres de um arquivo. public static String readString() { int carac; String cad = “”; boolean terminou = false; while (!terminou) {

21 try { carac = System.in.read(); if (carac < 0 || (char) carac == `\n`) terminou = true; else cad = cad + (char) carac; } catch(IOException e) { terminou = true; }...

22 CRIANDO SUAS PRÓPRIAS EXCEÇÕES

23 class MyException extends Exception { public MyException() {} public MyException(String msg) { super(msg); } public class Inheriting { public static void f() throws MyException { System.out.println("Throwing MyException from f()"); throw new MyException(); } public static void g() throws MyException { System.out.println("Throwing MyException from g()"); throw new MyException("Originated in g()"); } public static void main(String[] args) { try { f(); } catch(MyException e) { e.printStackTrace(); } try { g(); } catch(MyException e) { e.printStackTrace(); }

24 Criando suas próprias exceções Throwing MyException from f() MyException at Inheriting.f(Inheriting.java:16) at Inheriting.main(Inheriting.java:24) Throwing MyException from g() MyException:Originated in g() at Inheriting.g(Inheriting.java:20) at Inheriting.main(Inheriting.java:29)

25 Criando suas próprias exceções class MyException2 extends Exception { public MyException2() {} public MyException2(String msg) { super(msg); } public MyException2(String msg, int x) { super(msg); i = x; } public int val() { return i; } private int i; }

26 public class Inheriting2 { public static void f() throws MyException2 { System.out.println("Throwing MyException2 from f()"); throw new MyException2(); } public static void g() throws MyException2 { System.out.println("Throwing MyException2 from g()"); throw new MyException2("Originated in g()"); } public static void h() throws MyException2 { System.out.println( "Throwing MyException2 from h()"); throw new MyException2( "Originated in h()", 47); } public static void main(String[] args) { try { f(); } catch(MyException2 e) { e.printStackTrace(); } try { g(); } catch(MyException2 e) { e.printStackTrace(); } try { h(); } catch(MyException2 e) { e.printStackTrace(); System.out.println("e.val() = " + e.val()); }

27 Criando suas próprias exceções Throwing MyException2 from f() MyException2 at Inheriting2.f(Inheriting2.java:22) at Inheriting2.main(Inheriting2.java:34) Throwing MyException2 from g() MyException2: Originated in g() at Inheriting2.g(Inheriting2.java:26) at Inheriting2.main(Inheriting2.java:39) Throwing MyException2 from h() MyException2: Originated in h() at Inheriting2.h(Inheriting2.java:30) at Inheriting2.main(Inheriting2.java:44) e.val() = 47

28 Criando suas próprias exceções class SimpleException extends Exception { }

29 Especificação de Exceções

30 void f() throws tooBig, tooSmall, divZero { //... } void f() { //... }

31 EXCEÇÕES PADRÃO DO JAVA

32 Exceções padrão do Java Throwable :  Error  Exception

33 Exceções padrão do Java http://java.sun.com

34 Exceções padrão do Java Todas as classes herdam de java.lang.Exception Mas nem todas estão definidas em java.lang. Por exemplo: java.io.IOException

35 Exceções padrão do Java RuntimeException

36 Exceções padrão do Java: RuntimeException if(t == null) throw new NullPointerException();

37 Exceções padrão do Java: RuntimeException public class NeverCaught { static void f() { throw new RuntimeException("From f()"); } static void g() { f(); } public static void main(String[] args) { g(); }

38 Exceções padrão do Java: RuntimeException java.lang.RuntimeException: From f() at NeverCaught.f(NeverCaught.java:9) at NeverCaught.g(NeverCaught.java:12) at NeverCaught.main(NeverCaught.java:15)

39 Exceções padrão do Java: RuntimeException Se uma RuntimeException chega ao main sem ser capturada, printStackTrace( ) é chamado, e o programa sai.

40 Exceções padrão do Java: RuntimeException Uma RuntimeException significa um erro de programação:  Um erro do programador cliente, que passou um ponteiro nulo, causando uma NullPointerException  Um erro seu, que não verificou se estava acessando um índice válido do vetor, e causou uma ArrayIndexOutOfBoundsException

41 Finally

42  Frequentemente existe algum trecho de código que deve ser executado independente de uma exceção ter ou não ter sido disparada.  Problema: se o método alocou um recurso e uma exceção foi disparada, o recurso pode não ter sido liberado.

43  Apesar de Java possuir coleta de lixo, pode ser necessário retornar algum recurso não relacionado a memória para seu estado original.  Exemplos: fechar um arquivo, fechar uma conexão de rede, redesenhar algum componente na tela, etc.

44  Em Java: finally : indica o trecho de código que sempre será executado. Formato básico: try { // Código } catch(ClasseDeExcecao e) { // Manipulador da exceção } finally {... // Código que será } // executado sempre

45  Exemplo: em quaisquer circunstâncias, Java executará g.dispose(). Graphics g = image.getGraphics(); try {... } catch(IOException e) { terminou = true; } finally { g.dispose(); }

46  Possibilidades de execução do finally : O código não dispara exceções: tudo o que estiver no try e, em seguida, no finally, é executado. O código dispara uma exceção que é capturada por um catch : tudo o que estiver no try até a exceção ser disparada é executado. Depois, executa o código do catch e, por fim, o finally. O código dispara uma exceção que não é capturada por nenhum catch : tudo o que estiver no try até a exceção ser disparada é executado. Depois, executa o código do finally.

47 Restrições a exceções

48  Existe uma tendência a se abusar de exceções.  Exceções podem diminuir muito o desempenho do código.  Algumas dicas devem ser seguidas quando se está usando exceções.

49  Testes simples não devem ser substituídos por manipulação de exceções.  Exemplo: tentar desempilhar 1.000.000 de vezes uma pilha vazia. 1)if (!pilha.empty()) ---> 6 s pilha.pop(); 2)try { pilha.pop(); } ---> 64 s catch(EmptyStackException e){...}  Conclusão: use exceções apenas para circunstâncias excepcionais.

50  Não microgerencie exceções.  Exemplo: gravar os elementos de uma pilha num arquivo. for (i = 0; i < 100; i++) { try { n = pilha.pop(); } catch(EmptyStackException s){...} try { out.writeInt(n); } catch(IOException e){...} }  Se a pilha estiver vazia, continuará vazia; se houver um erro no arquivo, ele não sumirá.

51  Faz mais sentido colocar toda a operação no try. try { for (i = 0; i < 100; i++) { n = pilha.pop(); out.writeInt(n); } catch(IOException e) {...} catch(EmptyStackException s){...} }  Conclusão: o código fica mais limpo, garantindo a premissa básica.

52  Não bloqueie exceções.  Exemplo: carregar uma imagem de arquivo. Image loadImage(String nomearq) { try { // Inúmeras linhas } // de código catch (ClasseDeExcecao e) {} }  Conclusão: o programador deve se esforçar para gerenciar exceções corretamente.

53 Construtores

54 import java.io.*; class InputFile { private BufferedReader in; InputFile(String fname) throws Exception { try { in = new BufferedReader(new FileReader(fname)); // Other code that might throw exceptions } catch(FileNotFoundException e) { System.out.println( "Could not open " + fname); // Wasn't open, so don't close it throw e; } catch(Exception e) { // All other exceptions must close it try { in.close(); } catch(IOException e2) { System.out.println( "in.close() unsuccessful"); } throw e; } finally { // Don't close it here!!! } String getLine() { String s; try { s = in.readLine(); } catch(IOException e) { System.out.println( "readLine() unsuccessful"); s = "failed"; } return s; } void cleanup() { try { in.close(); } catch(IOException e2) { System.out.println( "in.close() unsuccessful"); }

55 Construtores public class Cleanup { public static void main(String[] args){ try { InputFile in = new InputFile("Cleanup.java"); String s; int i = 1; while((s = in.getLine()) != null) System.out.println(""+ i++ + ": " + s); in.cleanup(); } catch(Exception e) { System.out.println( "Caught in main, e.printStackTrace()"); e.printStackTrace(); }

56 Contrutores String getLine() throws IOException { return in.readLine(); }

57 Casamento de Exceções

58 class Annoyance extends Exception {} class Sneeze extends Annoyance {} public class Human { public static void main(String[] args) { try { throw new Sneeze(); } catch(Sneeze s) { System.out.println("Caught Sneeze"); } catch(Annoyance a) { System.out.println("Caught Annoyance"); }

59 Casamento de Exceções try { throw new Sneeze(); } catch(Annoyance a) { System.out.println("Caught Annoyance"); } catch(Sneeze s) { System.out.println("Caught Sneeze"); }

60 Conclusão

61 Use exceções para: 1)Consertar o problema e chamar o método que causou a exceção de novo 2)Contornar o erro e continuar sem tentar o método novamente 3)Calcular algum resultado alternativo em vez daquele que o método deveria produzir 4)Fazer o que for possível no contexto atual e lançar a mesma exceção para o contexto superior 5)Fazer o que for possível no contexto atual e lançar uma exceção diferente para o contexto superior 6)Terminar o programa 7)Simplificar. Se seu esquema de exceções complica as coisas, então ele será ruim para ser usado 8)Tornar sua biblioteca e seu programa mais seguros