Excepções Algoritmos e Tipos Abstractos de Informação (ATAI)

2 Uma excepção é um evento que ocorre durante a execução de um programa que interfere no fluxo normal das instruções deste programa. Em Java, a ocorrência de erros durante a execução de um programa não significa necessariamente que o programa termina. A linguagem possui um mecanismo para indicar partes críticas num programa e recuperar eventuais erros ocorridas nestas partes, sem parar a execução do programa. Este mecanismo é designado por Excepção (Exception). Uma Excepção é um sinal gerado pela máquina virtual de Java em tempo de execução do programa, que é comunicado ao programa indicando a ocorrência de um erro recuperável. O que é uma excepção

3 Erro e Excepção em Java Unchecked

4 Excepções Verificadas excepções que são verificadas pelo compilador derivam de Exception

5 Excepções não Verificadas excepções que não são verificadas pelo compilador derivam de RunTimeException

ATAI 6 Erro e Excepção em Java Erro Um Erro (Error) em Java corresponde a uma situação para a qual nenhuma recuperação é já possível. Descreve erros internos e a exaustão de recursos durante a execução do programa. Pouco se pode fazer se um erro interno desses ocorrer, além de notificar o utilizador e tentar finalizar o programa adequadamente. Essas situações são bastante raras. Excepção Uma Excepção (Exception) corresponde a uma situação para a qual a recuperação é possível. È um sinal gerado (lançado) pela máquina virtual de Java em tempo de execução do programa, indicando a ocorrência de um erro recuperável. A captura e o tratamento de Excepções contribui para a proclamada robustez do código dos programas Java, a par da tipificação dos dados e o modelo de memória sem apontadores.

7 Muitos tipos de erros podem provocar uma excepção, como por exemplo: Tentar aceder a uma tabela fora de seus limites, Tentar abrir um arquivo inexistente, Tentar ler um ficheiro para além do fim deste, Tentar abrir uma URL inexistente, Tentar dividir por zero, Tentar calcular a raiz quadrada de um número negativo. O que ocasiona uma Excepção

8 O uso de excepções não diminui o esforço necessário para se detectar, reportar e manipular erros. O uso de excepções permite a separação do código fonte regular do código responsável pelo tratamento das situações anómalas que podem acontecer no programa. Relativamente ao uso da instrução if possui as seguintes vantagens: Separação entre o tratamento de erros e o algoritmo. Propagação dos erros através da pilha de execução dos métodos. Divisão por grupos de erros organizados em hierarquia. Beneficios do uso de Excepções

9 Lançamento de Excepção Quando ocorre um erro recuperável dentro de um método, este cria um objecto da classe Exception e passa este objecto para o sistema de execução do Java (runtime) - lança uma Excepção. Este objecto contém informações sobre a excepção (seu tipo e o estado do programa quando o erro ocorreu). A partir deste momento, o sistema de execução do Java responsabiliza-se por encontrar o código que trate o erro ocorrido. O sistema passa a procurar o código capaz de tratar a excepção. A lista de candidatos para este tratamento vem da pilha de chamadas de métodos que antecederam o método que lançou a excepção. O sistema de execução do Java percorre a pilha de chamadas, e começa com o próprio método onde ocorreu o erro, na busca de um método que possua um gestor de Excepção ( catch ) adequado.

10 Se a excepção não for tratada e chegar à função main, o programa será interrompido com uma mensagem de erro. Um gestor de excepção é considerado adequado quando a excepção que ele manipula é do mesmo tipo da excepção lançada. Quando ele é encontrado, recebe o controle do programa para que possa tratar o erro ocorrido. Em outras palavras, diz-se que ele capturou a excepção (catch the exception). Se nenhum dos métodos pesquisados pelo sistema de execução possui um gestor de excepções adequado, então o programa Java em questão é abruptamente encerrado. Captura de Excepção

11 A linguagem Java permite a descrição de situações de excepção de uma forma normalizada através da utilização de 5 palavras chave correspondentes a cláusulas especiais, a saber: try catch finally throw throws try { // Trecho crítico do programa } catch(Excepção1 e1) { // Tratamento da e1 do tipo Excepção1 } catch(Excepção2 e2) { // Tratamento da e2 do tipo Excepção2 } ….. finally { // o bloco opcional // se existe executado sempre } Tratamento de Excepções

12 try O código do programa tal como seria escrito mesmo que garantidamente não pudesse gerar qualquer erro, é colocado neste bloco. Num bloco try passaremos a ter a possibilidade de detectar a ocorrência de alguns possíveis erros no código. catch(Identificador_da_excepção var_exc1) É aqui escrito o código de tratamento da excepção identificada na cláusula catch. var_exc1 é instância da excepção que foi gerada (e que pode ser usada). Podemos ter inúmeras cláusulas catch para o mesmo bloco try, cada uma correspondendo a uma classe de excepção diferente. Tratamento de Excepções Cláusulas try – catch

13 finally O código aqui colocado será sempre executado caso surja ou não uma excepção em try. Este código pode fazer o fecho de ficheiros, libertar recursos alocados, ou manipular variáveis. Se foi detectada excepção em try se existe uma cláusula catch local ao método, então o bloco catch é executado, e só depois o bloco finally. se não existe catch local para a excepção ocorrida, é executado o bloco finally e, caso exista, a cláusula catch externa ao método que primeiro for encontrada (por exemplo no método invocador). Se a forma de saída do bloco try, for return, continue ou break, quer exista ou não catch, o bloco finally é de imediato executado. Tratamento de Excepções Cláusula finally

14 Torna-se por vezes necessário no código de um dado método, "lançar" explicitamente uma excepção, ou seja, alertar explicitamente para uma situação de erro entretanto ocorrida na execução de tal código. Qualquer método tem a possibilidade de o fazer usando a cláusula throw e criando uma instância de uma dada excepção usando new. A linguagem Java requer que qualquer método que possa provocar a ocorrência de uma excepção normal, faça: Localmente o tratamento de tal excepção numa cláusula catch. Declare explicitamente que pode lançar tal excepção embora não a trate localmente. Neste último caso, no cabeçalho do método devem ser explicitamente declaradas todas as excepções que podem ser lançadas através de uma cláusula throws. Lançamento explícito de Excepções ( throw e throws )

15 Exemplo1 (sem tratamento de Excepção) Programa que lê dois inteiros e calcula a sua divisão class Ex1{ public static int divide(int a, int b) { return a/b; } public static void main(String[] args) { int num1, num2; System.out.println("Introduza o primeiro número"); num1=Le.umInt(); System.out.println("Introduza o segundo número"); num2=Le.umInt(); System.out.println(num1+ " / " + num2 + " = "+ divide(num1,num2)); } Quando num2 é igual a 0, causa o seguinte erro: java.lang.ArithmeticException: / by zero at Ex1.divide(exemplo1.java:5) at Ex1.main(exemplo1.java:15) o programa termina abruptamente

16 class Ex2{ public static int divide(int a, int b) { return a/b; } public static void main(String[] args) { int num1, num2; System.out.println("Introduza o primeiro número"); num1=Le.umInt(); System.out.println("Introduza o segundo número"); num2=Le.umInt(); try { System.out.println(num1+ " / " + num2 + " = "+ divide(num1,num2)); } catch (ArithmeticException e) { System.out.println("Não é possivel divisao por 0 "); } }} Programa que lê dois inteiros e calcula a sua divisão Exemplo2 (com tratamento de Excepção no main) Quando num2 é igual a 0, aparece a seguinte mensagem: Não é possivel divisao por 0 Finished executing Quando é executado o programa não termina, é mais robusto ! Excepção é capturada no main

17 class Ex3{ public static int divide(int a, int b) { try{ return a/b; } catch (ArithmeticException e) { System.out.println("Não é possivel divisao por 0 "); return -1; // não é boa solução } public static void main(String[] args) { int num1, num2; System.out.println("Introduza o primeiro número"); num1=Le.umInt(); System.out.println("Introduza o segundo número"); num2=Le.umInt(); int res = divide(num1,num2); if (res!=-1)System.out.println(num1+ " / " + num2 + " = "+ res); } Programa que lê dois inteiros e calcula a sua divisão Exemplo3 (com captura de Excepção no divide) Quando num2 é igual a 0, aparece a seguinte mensagem: Não é possivel divisao por 0 Finished executing Excepção é capturada no divide

18 class Ex4{ public static int divide(int a, int b) throws ArithmeticException { try{ return a/b; } catch (ArithmeticException e){ System.out.print("Erro: "); throw e; } public static void main(String[] args) { int num1, num2; System.out.println("Introduza o primeiro número"); num1=Le.umInt(); System.out.println("Introduza o segundo número"); num2=Le.umInt(); try { System.out.println(num1+ " / " + num2 + " = "+ divide(num1,num2)); } catch (ArithmeticException e) { System.out.println("Não é possivel " + e.getMessage()); } Não é obrigatório para RunTimeException Exemplo4 (com captura e lançamento de Excepção no divide e tratamento no main) Quando num2 é igual a 0, aparece a seguinte mensagem: Erro: Não é possivel / by zero Finished executing Excepção é capturada no divide

19 class Ex4{ public static int divide(int a, int b) { if (b==0) throw new ArithmeticException("Valor nulo!"); return a/b; } public static void main(String[] args) { int num1, num2; System.out.println("Introduza o primeiro número"); num1=Le.umInt(); System.out.println("Introduza o segundo número"); num2=Le.umInt(); try { System.out.println(num1+ " / " + num2 + " = "+ divide(num1,num2)); } catch (ArithmeticException e) { System.out.println("Não é possivel " + e.getMessage()); } }} Exemplo5 (com lançamento de Excepção no divide e tratamento no main) Quando num2 é igual a 0, aparece a seguinte mensagem: Não é possivel Valor nulo! Finished executing Excepção é capturada no divide

20 Exemplo class Exemplo{ public static void main (String[] args){ String codigo; char zona; int distrito, valido = 0; System.out.print ("Codigo do Produto (XXX para sair): "); codigo = Le.umaString(); while (!codigo.equals ("XXX")) { try { zona = codigo.charAt(2); distrito = Integer.parseInt(codigo.substring(3,5)); System.out.println ("Distrito " +distrito); valido++; } catch (StringIndexOutOfBoundsException exception) { System.out.println ("comprimento errado: " + codigo); } catch (NumberFormatException exception) { System.out.println ("Distrito não é numérico: " + codigo); } System.out.print (" Codigo do Produto (XXX para sair): "); codigo = Le.umaString(); } System.out.println ("Codigos validos: " + valido); }}

ATAI 21 Modelo baseado em três operações: Declaração das excepções Indicação ao compilador o que pode correr mal durante a execução de um método. Consiste na declaração das excepções que podem ocorrer durante a execução de um método Sintaxe: public voi meuMetodo() throws IOException, ArithmeticException …; Lançamento de excepções Um método poderá lançar as excepções que declarar ( excepto: RuntimeException ou Error ) Lançamento explicito Sintaxe1: throw new TheException ou Sintaxe2: TheException e = new TheException (); throw e; Lançamento Implícito Captura de excepções ponto do código para o qual o controlo do programa é transferido quando a excepção é lançada (try, catch, finally). Modelo das Excepções

22 RuntimeException Ocorre porque houve um erro de programação. Conversão explícita de tipo (cast) Acesso a elemento de uma tabela além dos limites. Acesso de ponteiro nulo IOException Tentar ler além do final de um arquivo Tentar abrir um URL incorrecto Tentar encontrar um objecto Class através de uma string que não denota uma classe existente. Classificação das Excepções

23 Classes de Excepção em Java

24 Excepções mais comuns ArithmeticException Indica situações de erros em processamento aritmético, tal como uma divisão inteira por 0. ArrayIndexOutOfBoundsException indica a tentativa de acesso a um elemento de um arranjo fora de seus limites -- ou o índice era negativo ou era maior ou igual ao tamanho do arranjo. NullPointerException indica que a aplicação tentou usar null onde uma referência a um objeto era necessária IOException indica a ocorrência de algum tipo de erro em operações de entrada e saída NumberFormatException indica que tentou-se a conversão de uma string para um formato numérico, mas seu conteúdo não representava adequadamente um número para aquele formato. ArrayStoreException Indica tentativa de armazenamento de um objecto não válido numa tabela IndexOutOfBoundsException Indica tentativa de usar um índice fora dos limite de uma tabela NegativeArraySizeException Indica tentativa de criar uma tabela com dimensão negativa NumberFormatException indica que tentou-se a conversão de uma string para um formato numérico, mas seu conteúdo não representava adequadamente um número para aquele formato. StringIndexOutOfBoundsException Indica tentativa de usar um índice numa string fora dos limite destas

25 Declaração explicita de Excepções Exemplo6 - uso de throws class LePalavras { public static void copiaPalavra(String [] tabPal, String palavra) throws ArrayIndexOutOfBoundsException, NumberFormatException { int index; System.out.print("Introduza um Indice :"); index = Integer.valueOf(Le.umaString().trim()).intValue(); tabPal[index]= palavra; } Este programa faz a leitura de uma sequência de Palavras e armazenamento de cada uma na posição de uma tabela cujo índice é introduzido pelo utilizador (sem validação prévia).

26 public static void main(String args[]) { int index, cont=0; final int MAX_PALAVRAS=5; String palavra = "" ; String[] tabPal = new String[MAX_PALAVRAS]; // Tabela de Palavras do{ try { System.out.print("\nIntroduza uma Palavra :"); palavra = Le.umaString(); copiaPalavra(tabPal, palavra); } catch (ArrayIndexOutOfBoundsException e){ System.out.println("Erro! indice ilegal"); } catch (NumberFormatException e) { System.out.println("Erro! é esperado um inteiro"); } cont++; } while (cont<MAX_PALAVRAS); System.out.println("Fim.."); } Declaração explicita de Excepções Exemplo6 - uso de throws

27 Lançamento de Excepções por um método Exemplo7 - uso de throw class LetabInteiros{ static public int [] criaTabInt(int tamanho) { int [] tabInt = new int[tamanho]; for (int i = 0 ; i < tamanho; i++) { System.out.print("\n Introduza " + i +" valor" ); tabInt[i] = Le.umInt(); } return tabInt; } criaTabInt Cria uma tabela de inteiros dinamicamente. Lê do teclado um conjunto de valores inteiros. Coloca cada valor lido na tabela.

28 Lançamento de Excepções por um método Exemplo7 - uso de throw (cont.) public static int elementoEm (int [] s, int index) throws ArrayIndexOutOfBoundsException { if (index -1) return s[index]; else { ArrayIndexOutOfBoundsException excepcao = new ArrayIndexOutOfBoundsException("erro no método elementoEm.."); throw excepcao; } Independente de outras excepções que possam ocorrer na execução, uma classe pode forçar o lançamento de excepções ou relançar uma determinada excepção, para que possa ser tratada em diferentes níveis. No método elementoEm o lançamento da excepção é explícita (ou programada) através do uso da instrução throw.

29 Lançamento de Excepções por um método Exemplo7 - uso de throw (cont.) public static void main(String args[]){ int [] tab; int index, valor, tabMax; boolean fim = false; System.out.print("\n Introduza o tamanho da tabela:"); tabMax = Le.umInt(); tab = criaTabInt(tabMax); do{ System.out.print("\n Introduza o indice:"); index = Le.umInt(); try { valor = elementoEm(tab,index); System.out.print("Valor na posicao: " +valor); } catch (ArrayIndexOutOfBoundsException e){ if ( index == -1) fim = true; else System.out.println(e); } while (!fim); System.out.println("Fim.."); } Este programa lê um conjunto de inteiros para uma tabela, em seguida retorna os valores lidos pela indicação do índice da tabela. O programa termina quando o índice é negativo.

30 Lançamento de Excepções por um método Exemplo8 - uso de throw (cont.) public static int elementoEm(int [] s, int index) throws ArrayIndexOutOfBoundsException { // retorna valor na posicao index try { return s[index]; } catch( ArrayIndexOutOfBoundsException e) // trata localmente a excepção. { if ( index >= s.length) { System.out.println("\nErro, indice ilegal. uso de indice 0"); index = 0; return s[index]; } else throw e; } // fim catch }// fim método Nesta variante do método elementoEm a excepção é capturada. É feito o tratamento do caso de tentativa do uso de um índice superior a dimensão da tabela. Nesta situação o índice é posto a 0. Para que seja possível o tratamento de índices negativos, no método main, a excepção é novamente lançada, através do uso de throw. Alteração do método elementoEm

31 O uso de excepções não diminui o esforço necessário para detectar, reportar e manipular erros. O uso de excepções permite a separação do código fonte regular do código responsável pelo tratamento das situações anómalos que podem acontecer no programa. Relativamente ao uso da instrução if possui as seguintes vantagens: Separação entre o tratamento de erros e o algoritmo. Propagação dos erros através da pilha de execução dos métodos. Divisão por grupos de erros organizados em hierarquia. Beneficios do uso de Excepções