Tratamento de Exceções em Java

Universidade Federal do Amazonas
Departamento de Ciência da Computação
IEC481 – Projeto de Programas
Tratamento de Exceções
em Java
Professor: César Melo
Slides baseados em materiais preparados pela
Profa. Rosiane Freitas e Prof. Horácio.
Tratamento de Exceções




Exceção é uma condição anormal ocorrida
durante a execução ou compilação de um
programa;
JAVA permite o tratamento de exceções;
Semelhante ao de C++, sendo feito através de 5
palavras-chave: try, catch, throw, throws e finally;
Toda exceção deve ser derivada da classe
THROWABLE;
Exceções
cortar(cebola);
panela.adicionar(cebola);
cortar(tomate);
panela.adicionar(tomate);
panela.adicionar(Oleo.medida(colher));
comer();
Exceções
tente
{ cortar(cebola);
panela.adicionar(cebola);
cortar(tomate);
panela.adicionar(tomate);
panela.adicionar(Oleo.medida(colher));
}
imprevisto(CortarDedo e)
{
dedo.aplicar(curativo);
}
comer();
Exceções

Condições que forçam a parada de um programa
ou a realização de ações especiais.


Por exemplo: divisão por zero.
Fornecem uma forma de notificar erros (ou
condições especiais) e de corrigí-los durante a
execução de um programa.
Exemplo
class Exemplo
{ public static void main(String[] a)
{ int[] vet = new int[3];
for(int c=0; c<4; c++) vet[c] = 0;
System.out.println(“Fim do programa.”);
}
}
Exemplo
class Exemplo
{ public static void main(String[] a)
{ int[] vet = new int[3];
try
{ for(int c=0; c<4; c++) vet[c] = 0; }
catch(Exception e)
{ System.out.println(“Houve um erro!”); }
System.out.println(“Fim do programa.”);
}
}
Exceções

Benefícios de 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.


deve existir um código no programa para tratar o erro.
não será possível compilar o programa caso tal tratamento não
seja fornecido.
Tipos de Exceções

Existem quatro categorias mais usuais:
1. Erros de código ou tipo de dados

coerção inválida, índice fora do limite do vetor, divisão por
zero.
2. Erros indicados pelos métodos já
existentes

ao usar o método substring() da classe String, ela pode gerar
uma exceção do tipo StringIndexOutOfBoundsException
Tipos de Exceções

Existem quatro categorias mais usuais:
3. Definição de novos tipos de exceções

veremos mais adiante como criar novos tipos de
exceções de acordo com as necessidades do
programa.
4. Erros de Java

erros causados pela Máquina Virtual Java que está
executando o programa do usuário.

em geral são causados por erros do próprio programa ou do
ambiente em que a JVM é executada e não da própria JVM.
try ... catch( ) ... finally ...
try bloco
catch(instância de uma subclasse de Exception) bloco
finally bloco



A palavra try marca o início do tratamento de
exceções.
try deve ser seguido de um ou mais catch e/ou
exatamente um finally.
O bloco finally é executado sempre, ocorrendo ou
não uma exceção.
try ... catch( ) ... 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
}
Execução Normal
A execução começa
no início do bloco
try
{
// Código que pode gerar uma exceção
}
O bloco finally é executado após
a execução normal do bloco try.
try
Havendo um return,
return o bloco finally
sempre será executado antes da
saída do método.
catch(MinhaExcecao1 e)
{
// Código para processar a exceção
}
Se não houver return no bloco try nem
no bloco finally,
finally a execução continua com
o código após o bloco finally
catch(MinhaExcecao2 e)
{
// Código para processar a exceção
}
finally
{
// Código que sempre será executado
}
Execução com Exceção
A execução começa
no início do bloco
A execução é interrompida no ponto
onde foi gerado a exceção.
O controle passa para o bloco
catch que capturá-la.
O bloco finally será executado logo
após o bloco catch.
catch
A execução continua com
o código após o bloco finally caso
não exista return.
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
}
Exemplo
class Exemplo
{ public static void main(String[] a)
{ int[] vet = new int[3];
try
{ for(int c=0; c<4; c++) vet[c] = 0; }
catch(ArrayIndexOutOfBoundsException e)
{ System.out.println(“Erro no vetor!”); }
catch(Exception e)
{ System.out.println(“Houve um erro!”); }
System.out.println(“Fim do programa.”);
}
}
Exemplo
class Exemplo
{ public static void main(String[] a)
{ int[] vet = new int[3];
try
{ for(int c=0; c<4; c++) vet[c] = 0; }
finally
{System.out.println(“Entrada garantida”);}
System.out.println(“Fim do programa.”);
}
}
Gerando uma Exceção

Métodos podem gerar exceções para indicar
condições de erro
public void meuMetodo()
throws IOException
{ ... }
public void meuMetodo()
throws IOException, OutraExcecao
{ ... }
Gerando uma Exceção

Os métodos que os utilizam devem tratar as
possíveis exceções
public void outroMetodo()
{ try
{ meuMetodo(); }
catch(IOException e)
{ // O tratamento é feito aqui
}
}
Exemplo
public double divisao(double n, double d)
throws Exception
{ if (d == 0.0)
{ throw new Exception(”denominador não ”+
“pode ser zero");
return 0.0; // nunca é executado!
}
else
return (n / d);
}
Exemplo
public void teste()
{double r =0.0;
try
{ r = divisao(3,0); }
catch(Exception e)
{ System.out.println(e.getMessage()); }
System.out.println(“A divisão é ”+r);
}

A exceção tem de ser tratada ou então
passada adiante!
Exemplo
public void teste() throws Exception
{ double r = 0.0;
r = divisao(3,0);
System.out.println(“A divisão é ”+r);
}

Uma exceção pode ser passada adiante até
gerar um erro de execução.
Reenviando Exceções
try
{ // comandos;
}
catch(Exception e)
{ // faz alguma coisa antes de sair;
throw e;
}
finally
{ // Também é executado
}
// Nunca passará por aqui se houver erro
Criando Novas Exceções

Uma exceção é um objeto
Exceções São Objetos
Exceções que podem ser
capturadas
Exceções que podem não ser
capturadas
Error Exceptions

Representam condições de erros as quais
não se espera que o programa possa
recuperá-las.


não se espera que o programa venha a tratá-las.
Exemplos:


falta de memória.
bytecode não encontrado dinamicamente.
Criando Uma Nova Exceção
public class NovaExcecao extends Exception
{
public NovaExcecao()
{ super(“Houve um novo erro!”);
}
public NovaExcecao(String msg)
{ super(msg);
}
}
Porque Usar Exceções?



Tratar exceções ajuda a escrever o
processamento de erros em um único lugar.
Os erros descritos por um método não podem ser
ignorados.
Exceções são objetos:

podem combinar dados e métodos
ROBUSTEZ
Tratamento de Exceções em Java

Dúvidas?
Divisão por Zero


Uma divisão inteira por zero gera uma
exceção.
Uma divisão real por zero não gera uma
exceção.


Aritmética de ponto-flutuante segue o padrão
IEEE 754.
Valores de retorno:

POSITIVE_INFINITY, NEGATIVE_INFINITY, ...
Exceções Internas

É possível escrever instruções aritméticas
sem se preocupar explicitamente com a
checagem de erros.
int div(int a, int b)
{ return (a / b); }
Exceções Internas
int div(int a, int b)
{ return (a / b); }
void teste()
{ int a=1, b=0, c=3;
System.out.prinln(a+“/”+b+“=”+div(a,b));
System.out.prinln(b+“/”+c+“=”+div(b,c));
}
Exceções Internas
int div(int a, int b)
{ return (a / b); }
void teste()
{ int a=1, b=0, c=3;
try
{ System.out.prinln(a+“/”+b+“=”+div(a,b));
System.out.prinln(b+“/”+c+“=”+div(b,c));
}catch(Exception e)
{ System.out.println(e); }
}