excepções algoritmos e tipos abstractos de informação (atai)

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

compiladorderivam 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 JavaErro

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 catchfinally throwthrows

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ãoclass 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) {


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


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


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)


Erro: Não é possivel / by zeroFinished executingExcepçã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) {


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)


Não é possivel Valor nulo!Finished executing

Excepção é capturada no divide

20

Exemploclass 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

Object

Throwable

NoSuchElementException

EmptyStackException

ArithmeticException

ArrayStoreException

ClassCastException

IllegalArgumentException

IllegalMonitorStateException

IndexOutOfBoundsException

NegativeArraySizeException

NullPointerException

ClassNotFoundException

CloneNotSupportedException

IllegalAccessException

InstantiationException

InterruptedException

NoSuchMethodException

RunTimeException RunTimeException

AWTException

SecurityException

Object

Exception

AWTException

IOException

java.lang

java.awt

java.io

java.util

24

Excepções mais comuns

ArithmeticExceptionIndica 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

IOExceptionindica a ocorrência de algum tipo de erro em operações de entrada e saída

NumberFormatExceptionindica 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

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

StringIndexOutOfBoundsExceptionIndica tentativa de usar um índice numa string fora dos limite destas

25

Declaração explicita de ExcepçõesExemplo6 - 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çõesExemplo6 - 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


Exemplo7 - uso de throw (cont.)public static int elementoEm (int [] s, int index) throws ArrayIndexOutOfBoundsException { if (index < s.length && 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


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


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

excepções algoritmos e tipos abstractos de informação (atai)

Documents