Paradigmas de Programação
Excepções
Uma excepção é um objecto criado quando uma situação
anómala ocorre, acompanhado por uma interrupção de
execução normal do programa.
Uma excepção contém informação sobre:
- o tipo de erro
- o estado do programa quando o erro ocorre
Quando ocorre uma excepção o fluxo de execução é detido e o
programa passa o controlo para onde é “apanhada” a excepção.
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
1
Paradigmas de Programação
O “apanhar” da excepção pode ser feito:
- no método responsável pelo lançamento da excepção e então é tratada
localmente.
- o método onde a excepção é lançada, não a trata, ela é transferida para quem
invocou este segundo método e nesse é tratada ou é transferida para quem
invocou este último método e assim por diante. Se nenhum método da
sequência de evocações tratar a excepção, o programa pára e envia um relatório
de erro.
Vantagens do mecanismo de excepções :
• Separa o código do tratamento de erros do código restante
• Permite a propagação de erros através dos métodos invocados
• Permite agrupar tipos de erros relacionados
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Helena Leitão
2
Paradigmas de Programação
As excepções são derivadas da classe Throwable que tem os
métodos:
String getMessage( ) devolve o relatório enviado por
quem lançou a excepção.
void printStackTrace( ) escreve o caminho percorrido
pela excepção desde que foi
lançada até ser apanhada.
string toString( )
Ano Lectivo 2009/2010
devolve uma string com a
descrição da excepção.
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
3
Paradigmas de Programação
Há a considerar a seguinte hierarquia nas classes que
manipulam excepções.
Object
Throwable
java.lang.Trowable
Exception
Error
Não são recuperaveis,
não são verificadas pelo
compilador
---Ex: OutOfMemoryError,
Verificaveis pelo compilador,
VirtualMachineError
obrigatoriamente precisam de ser
tratadas durante a execução
Ex: IOException
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
RuntimeException
Não são verificáveis pelo
compilador (implícitas)
Ex:
IndexOutOfBoundsException
4
Paradigmas de Programação
Caso geral de tratamento de uma excepção:
O método que causa a excepção dentro de um bloco try ...catch
O código de tratamento da excepção no bloco catch (pode ter mais do que um
catch)
try {
//método que causa a excepção
} catch ( ExcepçaoTipo1 e ){
//código de tratamento da excepção ExcepçaoTipo1
}catch (ExcepçãoTipo2 e ){
//código de tratamento da excepção ExcepçaoTipo2
//eventualmente pode relançar a excepção throw e;
}finally {
//código que tem que executar quer tenha havido excepção
//quer não
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
5
Paradigmas de Programação
1-Verifique a ocorrência da excepção
Se escrevermos uma letra em vez de um inteiro, surgirá
uma excepção NumberFormatException
public static void main(String [] args) {
String s;
int x;
s=JOptionPane.showInputDialog(”Escreva um inteiro”);
x=Integer.parseInt(s);
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
6
Paradigmas de Programação
2-Vamos pedir o número dentro do bloco try--catch para tratarmos
a excepção.
try{
s=JOptionPane.showInputDialog(“Escreva um inteiro”);
x=Integer.parseInt(s);
}catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null,nfe.getMessage());
//neste caso se ocorrer a excepção não escreve FIM há um return
return;
}
JOptionPane.showMessageDialog(null,"FIM”);
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
7
Paradigmas de Programação
3-Vamos repetir o 2, mas colocar a escrita de FIM no bloco
finally
try {
s=JOptionPane.showInputDialog("Escreva um inteiro“);
x=Integer.parseInt(s);
}catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null,nfe.getMessage());
//neste caso, se ocorrer a excepção é escrita a mensagem correspondente à mesma,
//passando depois à execução do bloco finally escrevendo FIM e finalmente faz return.
return; //se tivesse System.exit(1); não executava o bloco finally
}
finally{
JOptionPane.showMessageDialog(null,"FIM“);
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
8
Paradigmas de Programação
4- Tratamos a excepção não no método que a lança ( lerInteiro() ) mas no que o
invocou, neste caso o main( )
public static void main(String [] args) {
try {
int x=lerInteiro();
}catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null,nfe.getMessage());
}
}
private static int lerInteiro() {
//a excepção não é declarada (throws NumberFormatException) porque é RuntimeException
String s;
int x;
s=JOptionPane.showInputDialog(“Escreva um inteiro“);
x=Integer.parseInt(s); //aqui é lançada a excepção
return x; }
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
9
Paradigmas de Programação
Exercício:
Num programa que lê um valor inteiro, faça a sua
validação através do tratamento de uma excepção
para o efeito. Caso não seja um valor válido deve
continuar o pedido de introdução de valor inteiro.
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
10
Paradigmas de Programação
// Pede um valor inteiro enquanto o valor entrado não for inteiro
public class ExcepcoesLerInteiro {
public static void main(String [] args) {
String s;
int x;
boolean errado=true;
do{
try {
s=JOptionPane.showInputDialog(“Escreva um inteiro”);
x=Integer.parseInt(s);
errado=false;
}catch (NumberFormatException nfe) {
JOptionPane.showMessageDialog(null,nfe.getMessage());
//neste caso se ocorrer a excepção escreve FIMCatch executa o bloco finally
JOptionPane.showMessageDialog(null,"FIM Catch”);
} finally{
JOptionPane.showMessageDialog(null,”FINALLY”);
}
}while(errado);
JOptionPane.showMessageDialog(null,"Fim Programa");
}
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
11
Paradigmas de Programação
Exemplo em que se criam as nossas excepções.
Ler um número inteiro e positivo:
public class MinhaExcepcao extends Exception{
public MinhaExcepcao() {
super("A minha Excepção");
}
public MinhaExcepcao(String msg) {
super(msg); }
}
Para uma nova excepção deve escolher-se para super classe uma das
seguintes:
Exception – se a excepção deve ser verificada (obrigatoriamente tratada)
RuntimeException – se não é importante obrigar a verificar a excepção
(ocorre de vez em quando)
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
12
Paradigmas de Programação
private static int lerIntPos() throws MinhaExcepcao{
String s;
int x;
s=JOptionPane.showInputDialog(“Escreva um inteiro”);
x=Integer.parseInt(s); //se não for inteiro lança a excepção NumberFormatException
if (x<0) //se não for positivo lança a excepção MinhaExcepção
throw(new MinhaExcepcao("Atenção o valor é negativo"));
return x;
}
A classe MinhaExcepção, como extends Exception e no método onde é
lançada, lerIntPos(), não é feito o catch, obrigatoriamente tem que ser
declarada (throws) no cabeçalho desse método.
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
13
Paradigmas de Programação
public static void main(String [] args) {
int x;
try {
x=lerIntPos();
}catch (NumberFormatException nfe){
JOptionPane.showMessageDialog(null,nfe.getMessage());
}catch (MinhaExcepcao me) {
JOptionPane.showMessageDialog(null,me.getMessage());
}
JOptionPane.showMessageDialog(null,"FIM”);
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
14
Paradigmas de Programação
Responda às seguintes questões:
1.
O que entende por excepção?
2.
Enumere as 5 palavras chave usadas em Java para lançamento e
tratamento de excepções.
3.
Assinale verdadeiro ou falso em cada uma das afirmações abaixo
indicadas:
a) É possível colocar como argumentos de catch, uma lista de
argumentos separados por vírgulas.
Verdadeiro
Falso
b) Pode usar-se 2 blocos catch associados a um try, para o mesmo
tipo de excepção.
Verdadeiro
Falso
c) Pode usar-se 2 blocos catch associados a um try para tipos
diferentes de excepções.
Verdadeiro
Ano Lectivo 2009/2010
Falso
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
15
Paradigmas de Programação
d) Sabendo que a classe MinhaExcepcao extends Exception, é possível usar o
seguinte código ?
Verdadeiro
Falso
try { .....
}catch(Exception e){
…
}
catch(MinhaExcepcao me){
…
}
4. Atender ao código a seguir e responder às seguintes questões:
a) A aplicação apresenta um erro de compilação. Indique qual.
b) Apresente duas soluções para correcção desse erro.
c) Corrigido o erro, qual seria o resultado da execução?
d) Substituindo o valor de a para -3, qual seria o resultado da execução?
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
16
Paradigmas de Programação
public class BrancoException extends CorException{
public BrancoException() {
System.out.println("BrancoException");
}
}
public class CorException extends Exception {
public CorException() {
System.out.println("CorException");
}
}
public abstract class Cor {
public abstract void ml() ;
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
17
Paradigmas de Programação
public class Branco extends Cor
{
public void ml() throws BrancoException{
throw new BrancoException();
}
public static void main(String[] args){
Branco branco = new Branco();
int a,b,c; a=b=c=0;
try{
if(a>=0){ branco.ml(); a++; }
}catch(CorException e){ b++; }
finally{ c++;
}
System.out.println(a+" , "+b+" , "+c);
}
}
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
18
Paradigmas de Programação
Resultados do exercício 4:
a) ml() em Branco não pode reescrever ml() em Cor
b-1) O método ml() na classe Cor devia apresentar o seguinte protótipo:
abstract void ml() throws BrancoException
ou
abstract void ml() throws CorException
b-2) Evitar-se-ia também este erro se CorException fosse subclasse de
RuntimeException em vez de ser subclasse de Exception
c)
CorException
brancoException
0, 1, 1
d) -3, 0, 1
Ano Lectivo 2009/2010
Tópicos das aulas Teórico Práticas
Helena Leitão & Dulce Mota
19