Excepções JAVA

Excepções

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

O que é uma excepção
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.

2

Erro e Excepção em Java

Unchecked

3

Excepções Verificadas

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

4

Excepções não Verificadas

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

5

Erro e Excepção em Java
Erro Excepção

 Um Erro (Error) em Java  Uma Excepção (Exception)
corresponde a uma situação corresponde a uma situação para a
para a qual nenhuma qual a recuperação é possível.
recuperação é já possível.
 È um sinal gerado (lançado) pela
 Descreve erros internos e a máquina virtual de Java em tempo
exaustão de recursos durante a de execução do programa, indicando
execução do programa. a ocorrência de um erro recuperável.

 Pouco se pode fazer se um erro  A captura e o tratamento de
interno desses ocorrer, além de Excepções contribui para a
notificar o utilizador e tentar proclamada robustez do código dos
finalizar o programa programas Java, a par da tipificação
adequadamente. dos dados e o modelo de memória
sem apontadores.
 Essas situações são bastante
raras.

ATAI 6

O que ocasiona uma Excepção

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

7

Beneficios do uso de Excepções
 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.

8

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.

9

Captura de Excepção
 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.

10

Tratamento de Excepções
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 try
{
catch // Trecho crítico do programa
finally }
catch(Excepção1 e1)
throw {
throws // 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
}

11

Cláusulas try – catch
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.

12

Cláusula finally
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.

13

Lançamento explícito de Excepções
(throw e throws)

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.

14

Exemplo1
(sem tratamento de Excepção)
Programa que lê dois inteiros
class Ex1{
e calcula a sua divisão
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

15

Exemplo2
(com tratamento de Excepção no main)
class Ex2{
{
return a/b;
} e calcula a sua divisão
int num1, num2;
num1=Le.umInt();
num2=Le.umInt();
try
{
}
catch (ArithmeticException e)
{
System.out.println("Não é possivel divisao por 0 ");
}
Quando num2 é igual a 0, aparece a seguinte
}} mensagem:

Não é possivel divisao por 0
Excepção é capturada no main Finished executing

Quando é executado o programa não termina, é mais
robusto !

16

Exemplo3
(com captura de Excepção no divide)
class Ex3{
{
try{
return a/b; e calcula a sua divisão
}
{
System.out.println("Não é possivel divisao por 0 ");
return -1; // não é boa solução
}
}
int num1, num2;
num1=Le.umInt();
num2=Le.umInt();
int res = divide(num1,num2);
if (res!=-1)System.out.println(num1+ " / " + num2 + " = "+ res);

} Quando num2 é igual a 0, aparece a seguinte
} mensagem:

Excepção é capturada no divide Não é possivel divisao por 0
Finished executing

17

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

Exemplo5
(com lançamento de Excepção no divide e tratamento no main)

class Ex4{
{
if (b==0) throw new ArithmeticException("Valor nulo!");
return a/b;
}
int num1, num2;
num1=Le.umInt();
num2=Le.umInt();
try {
}
{
System.out.println("Não é possivel " + e.getMessage());
}
}} mensagem:

Excepção é capturada no divide Não é possivel Valor nulo!
Finished executing

19

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

20

Modelo das Excepções
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).

ATAI 21

Classificação das Excepções

RuntimeException IOException

 Ocorre porque houve um erro de •Tentar ler além do final de um
programação. arquivo
 Conversão explícita de tipo
•Tentar abrir um URL incorrecto
(cast)

 Acesso a elemento de uma •Tentar encontrar um objecto
tabela além dos limites . Class através de uma string que
não denota uma classe existente.
 Acesso de ponteiro nulo

22

Classes de Excepção em Java
java.util
java.lang EmptyStackException

NoSuchElementException
ClassNotFoundException

ArithmeticException
CloneNotSupportedException
Object
ArrayStoreException
IllegalAccessException
Throwable
ClassCastException
InstantiationException
Exception
IllegalArgumentException
InterruptedException

IllegalMonitorStateException
NoSuchMethodException

IndexOutOfBoundsException
RunTimeException

NegativeArraySizeException
java.awt
AWTException
NullPointerException

java.io IOException
SecurityException

23

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

24

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

25

Declaração explicita de Excepções
Exemplo6 - uso de throws
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..");
}
} 26

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.

27

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.

28

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;  Este programa lê um conjunto de inteiros para
else uma tabela, em seguida retorna os valores lidos
System.out.println(e);
} pela indicação do índice da tabela.
}  O programa termina quando o índice é
while (!fim);
System.out.println("Fim.."); negativo.
}
}
29


public static int elementoEm(int [] s, int index)
throws ArrayIndexOutOfBoundsException { // retorna valor na posicao index

try
{ Alteração do método elementoEm
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];
}  Nesta variante do método elementoEm a excepção é capturada.
else
 É feito o tratamento do caso de tentativa do uso de um índice superior a
throw e;
dimensão da tabela.
} // fim catch  Nesta situação o índice é posto a 0.
 Para que seja possível o tratamento de índices negativos, no método main,
}// fim método a excepção é novamente lançada, através do uso de throw.

30

Beneficios do uso de Excepções
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.

31

Excepções JAVA

Mais conteúdo relacionado

Mais procurados

Semelhante a Excepções JAVA

Mais de Pedro De Almeida

Último

Excepções JAVA