Paradigmas de Linguagens de Programação - Tratamento de Exceções

Prof. Adriano Teixeira de Souza
Sistemas de tratamento de exceções
Exceções em Java

 Componentes podem ter problemas
durante a execução e reagir como:
◦ terminar o programa;
◦ retornar um valor de erro indicando falha;
◦ retornar e ignorar o problema;
◦ chamar uma função para tratar o erro, etc...
 Problemas: erros e exceções
◦ representam situações anormais (exceções) ou inválidas
(erros) durante o processo de execução
 Componentes robustos: tentam sanar os
problemas


 Os problemas comuns de execução:
◦ falha na aquisição de um recurso (new, open..)
◦ tentativa de fazer algo impossível (divisão por zero,
índice inválido..)
◦ outras condições inválidas (lista vazia, overflow..)

classe

objeto.metodo() dados
método()


 Premissas:
◦ Possíveis problemas de execução de um método podem
ser antecipados pelo programador
◦ Situações de erro podem ser revertidas

 Solução ideal
◦ tratamento de problemas separado do código normal
◦ Mecanismo: sistemas de tratamento de exceções (STE)


 Mecanismos oferecidos pela LP
 Um STE deve ser capaz de :
◦ detectar a ocorrência de uma situação anormal de
processamento

◦ identificar o tipo de ocorrência e enviar um sinal ao
programa (disparar uma exceção)

◦ capturar a exceção em algum ponto do programa

◦ tratar uma exceção em algum ponto do programa
(ativar tratador)

disparar detectar capturar tratar


 Exceções podem ser disparadas de duas
maneiras:
◦ Implicitamente, pelo ambiente operacional
 o ambiente de execução não consegue executar um
comando em um programa

◦ Explicitamente, pelo programa
 uma função do programa não consegue prosseguir a
execução



public class Zero {
public static void main ( String[] args){
int numerador = 10;
int denominador = 0;
System.out.println(numerador/denominador);
} // main
mensagem
} // Zero do JRE

execução: java.lang.ArithmeticException: / by zero
at Zero.main(Zero.java:xx)

xx: número da linha do arquivo fonte onde ocorreu o erro


 Indicação da região do programa que deve
ser monitorada pelo sistema de tratamento
de exceções
 Sintaxe: try {<bloco de comandos>}
 Exemplo: comandos que podem
disparar exceções
try {
num= Integer.parseInt(stdin.readLine());
valido = true;
}



 Um comando catch tem as seguintes funções:
 capturar um (determinado) tipo de exceção
 implementar um tratador para aquele tipo de
exceção
 Sintaxe: catch(<tipo><arg>){<comandos>}
 Exemplo:

catch (NumberFormatException exc) {
System.out.println(“Entrada invalida. Digite outra”);
}



try {
valido = true;
}
}
catch (IOException exc) {
System.out.println(“Problema de entrada. Terminando!”);
System.exit(0);
}


 Exceções são objetos, instâncias de alguma
sub-classe de java.lang.Throwable
◦ podem conter dados
◦ podem definir métodos
 Um dos dados é um String inicializado em
tempo de criação do objeto, consultado por
◦ Throwable.getMessage()
 Throwable tem duas sub-classes: Error e
Exception.
◦ Exceptions: podem ser capturadas e tratadas
◦ Errors: correspondem a problemas mais graves, que não
podem ser recuperados


 Instâncias da classe Error e suas extensões
◦ correspondem a problemas mais graves ocorridos no
ambiente de execução
◦ conhecidas como exceções não-verificadas
 Instâncias da classe Exception e suas
extensões
◦ podem ser tratadas localmente
◦ conhecidas como exceções verificadas: o compilador
“verifica” antes da execução do programa
◦ comandos que disparam exceções verificadas devem ser
colocados em um bloco try


Exception: hierarquia de exceções

Exception
java.lang

IOException Runtime
java.io Exception
contexto:
java.lang.Object | NumberFormat
java.lang.Throwable |
java.lang.Exception Exception


 Tratar exceções cria um fluxo de controle
separado do fluxo normal de execução
 Abordagens:
◦ tratar a exceção onde ela ocorre ( local)
◦ tratar a exceção em outro ponto do programa

tratador de
exceção

unidade de unidade de
chamada execução


comando anterior;
try {
valido = true;
}
}
System.exit(0);
}
comando posterior;


comando anterior;
try {
valido = true;
}
}
OU
System.exit(0);
}
comando posterior;


chamada execução

método()

• Modelos de implementação

Término: após a execução do tratador de exceção,
a unidade onde ocorreu o erro é terminada

Continuação: após a execução do tratador de exceção,
a unidade continua a sua execução

A: chamada B: execução

método()

tratador no requisitante tratador local
Hipótese 1: Hipótese 2:
- B acusa erro e termina a - B faz tratamento local
execução de erro
- A captura o erro e trata a - Caso não consiga recuperar
exceção o erro, recai na Hipótese 1


 Para buscar o tratador de exceção:
◦ percorre a ‘cadeia’ de ativações, a partir do ambiente
local (pilha de execução)

◦ durante o caminho, são destruídos os objetos criados
nos ambientes percorridos (retira da pilha de execução)

◦ se não for encontrado um tratador a exceção a exceção
chega ao método main, que termina o programa

m2()
m1()
Ver: método printStackTrace() main()


 Sinal emitido pelo programa com a
indicação da ocorrência de uma exceção
◦ if (…problema…)
throw new IOException( );

 Instanciação a partir de uma classe
◦ throw new <classe()>
◦ Exemplo: if (t==null) throw new NullPointerException();

 Objeto já instanciado
◦ throw <objeto>
◦ Exception problema = new Exception (“Alerta!”);
◦ Exemplo:.... throw problema; ...


 Considerando que:
◦ a unidade de execução pode detectar problemas mas
geralmente não sabe como tratá-lo
◦ a unidade requisitante não pode detectar problemas
mas geralmente sabe como tratá-los
◦ é conveniente saber quais são as exceções que um
método pode disparar para providenciar um tratador

 Cláusula throws : usada no cabeçalho de
um método para indicar que ele propaga a
exceção

 Exemplo:
◦ public Integer(String s) throws NumberFormatException


 Para forçar a ocorrência de uma exceção,
utiliza-se a palavra reservada throw (no
singular)
public void metodo1( ) {
try {
throws (plural)
metodo2( ); propaga exceção
} catch (IOException e) { System.err.println(e); }
}

public void metodo2( ) throws IOException {
if (…problema…)
throw new IOException( );
}

public String readLine()
import java.io.*;
throws IOException
public class simplesIO {
static BufferedReader stdin=new BufferedReader
(new InputStreamReader(System.in));
public static void saida(String ms){
System.out.print (ms);
}
public static String entrada() throws IOException{
return stdin.readLine();
}
public static void linha(){
// exemplo de chamada:
System.out.println();
} try{linha=entrada();}
}//simplesIO catch(IOException e){}


import java.io.*;
public class simplesIO {
static BufferedReader stdin=new BufferedReader
(new InputStreamReader(System.in));
public static void saida(String ms){
System.out.print (ms);}
public static String entrada(){
try { String lin= stdin.readLine();
return lin;
} catch(IOException){// tratar aqui}
}
public static void linha(){
System.out.println(); // exemplo de chamada:
}
linha=entrada();
}//simplesIO

Exceções definidas pelo usuário

Exception
java.lang

IOException RunTime
java.io Exception

Minha NumberFormat
Exception Exception


// definição da exceção
class TempExc extends Exception{
public TempExc () { super(); } // executa Exception()
public TempExc (String s) {System.out.println(s + "n");}
}

// dispara e propaga exceção
try{ metodo();}
void metodo() throws TempExc {
catch(TempExc e){
throw new TempExc();
}
}


try { .... }
catch (Tipo1 exc) { .....}
catch (Tipo2 exc) {......}
 A cláusula finally finally {<bloco de comandos>}
◦ é utilizada para forçar a execução de um bloco de
código
◦ associada a um bloco try
◦ pode ser utilizada com ou sem o bloco catch
 A cláusula finally é executada nas seguintes
condições:
◦ fim normal do método
◦ devido a uma instrução return ou break
◦ caso uma exceção tenha sido gerada


 Dado o seguinte enunciado: Escreva um
programa em JAVA que recebe dois strings,
S1 e S2 e um número N pela linha de
comando e imprima:

◦ Os N primeiros caracteres do String S1 separados por
um “-”;
◦ Os N primeiros caracteres do String S1 de traz para
diante;
◦ Os N primeiros caracteres do String S2 separados por
um “-”;
◦ Os N primeiros caracteres do String S2 de traz para
diante.


class ImpString { public class TestaExceptions{
public static void impSep(String str,int n){ static public void main(String args[]){
String aux = "";
String s1,s2;
for(int i=0; i<n; i++){
int n;
aux = aux + str.charAt(i);
if (i < n-1) aux = aux + '-';
} s1 = args[0];
System.out.println(aux); s2 = args[1];
} n = Integer.parseInt(args[2]);
public static void impInv(String str,int n){
String aux = "";
for(int i=n-1; i>=0; i--) ImpString.impSep(s1,n);
aux = aux + str.charAt(i); ImpString.impInv(s1,n);
System.out.println(aux);
ImpString.impSep(s2,n);
}}
ImpString.impInv(s2,n);
}
}

 A solução anterior está correta se:
◦ O usuário informar os 3 parâmetros na linha de
comando;

◦ O terceiro parâmetro for um número;

◦ O valor de N for menor ou igual ao comprimento dos
strings informados;

 O tratamento de situações de erro é
fundamental em aplicações reais !


 Exemplo:

Entrada: Entrada:
Teste exceções 4 Teste exceções 10
Saída: Saída:
T-e-s-t java.lang.StringIndexOutOfBoundsEx
tseT ception: String index out of range: 5
e-x-c-e
ecxe
Entrada: Entrada:
Teste Teste Teste Teste
Saída: Saída:
java.lang.NumberFormatExce java.lang.StringIndexOutOfBoundsExc
ption: Teste eption: 1


public class TestaExceptions{
static public boolean intOk(String s){
for(int i=0; i<s.length(); i++)
if (Character.isDigit(s.charAt(i)) == false) return(false);
return(true);
}
public static void main(String args[]){
String s1,s2; Código normal entrelaçado com
int n; código excepcional:
if (args.length != 3){ acrescentou 14 linhas executáveis
System.out.println("Sintaxe: <string> <string> <int>");
System.exit(0);
}
if (intOk(args[2]) == false){
System.out.println("O terceiro parâmetro deve ser um inteiro");
System.exit(0);
}
(continua...)


(...continua)

s1 = args[0]; s2 = args[1];
n = Integer.parseInt(args[2]);
if (n < s1.length()){
}
else System.out.println("O valor de n é maior que o tamanho de S1");

if (n < s2.length()){
}
else System.out.println("O valor de n é maior que o tamanho de S2");
}
}

try{
public class TestaExceptions{ ImpString.impInv(s1,n);
static public void main(String args[]){ ImpString.impSep(s2,n);
String s1=""; ImpString.impInv(s2,n);
String s2=""; }
int n=0; catch(Exception e){
try{ System.out.println("O valor de N é
s1 = args[0]; maior que S1 ou S2");
s2 = args[1]; System.exit(0);
n = Integer.parseInt(args[2]); }
} }
catch(Exception e){ }
System.exit(0);
}


catch(NumberFormatException e){
static public void main(String
System.out.println("O terceiro argumento deve
args[]){
String s1=""; ser um int");
String s2=""; } catch(IndexOutOfBoundsException e){
int n=0; System.out.println("Sintaxe: <string> <string>
try{ <int>");
s1 = args[0]; } catch (Exception e){
s2 = args[1]; System.out.println("O valor de N é maior que S1
ou S2");
}finally{
System.out.println(”Sempre passa por aqui !!"); }
}
} }


class MinhaExcecao extends Exception{
private int val;
public MinhaExcecao(int n){
super("Minha excecao: valor de val="+n);
val = n;
}
public int getVal(){ return(val); }
}

class ImpString {
public static void impSep(String str,int n) throws MinhaExcecao{
String aux = "";
if (n == 0) throw(new MinhaExcecao(n));
for(int i=0; i<n; i++){
if (i < n-1) aux = aux + '-';
}
}
(continua...)


public static void impInv(String str,int n){
String aux = "";
for(int i=n-1; i>=0; i--)
}}
static public void main(String args[]){
String s1="";
String s2="";
int n=0;
try{
s1 = args[0];
s2 = args[1];
} (continua...)


(...continua)

catch(NumberFormatException e){
System.out.println("O terceiro argumento deve ser um int");
}
catch(IndexOutOfBoundsException e){
}
catch(MinhaExcecao e){
System.out.println(e.getMessage());
int x = e.getVal();
}
catch(Exception e){
System.out.println("O valor de N é maior que S1 ou S2");
}
finally{
System.out.println("É obrigado a passar por aqui");
}
}
}


Paradigmas de Linguagens de Programação - Tratamento de Exceções

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Destaque

Destaque (9)

Semelhante a Paradigmas de Linguagens de Programação - Tratamento de Exceções

Semelhante a Paradigmas de Linguagens de Programação - Tratamento de Exceções (20)

Mais de Adriano Teixeira de Souza

Mais de Adriano Teixeira de Souza (20)

Paradigmas de Linguagens de Programação - Tratamento de Exceções