03/11/2008

Java Básico

Tratamento de Exceções
Prof. Jucimar Souza
jucibs@gmail.com

Objetivos

Entender exceções e tratamento de erros;

Ser capaz de utilizar blocos try para delimitar o código
em que uma exceção pode ocorrer;

Ser capaz de disparar (throw) exceções;

Utilizar os blocos catch para especificar tratadores de
exceções;

Utilizar o bloco finally para liberar recursos;

Entender a hierarquia de exceções em Java

Criar exceções definidas pelo programador.

1
 03/11/2008

6.1 - Fundamentos

Uma exceção é uma condição anormal que ocorre

durante a execução de uma seqüência de código.

Em linguagens como Object Pascal e C++ o
tratamento de exceção é opcional, mas em Java é
obrigatório.

Sempre que houver um método que possa gerar
uma exceção, a classe que utilizar este método
será obrigada a tratar de alguma forma a possível
exceção. Se não, ocorrerá um erro de compilação.

Vamos executar o programa TesteErro.java e
visualizar um erro e entender o que está
acontecendo.

Este é rastro de pilha (stacktrace)

class TesteErro {
public static void main(String[] args) {
System.out.println("inicio do main");
metodo1();
System.out.println("fim do main");
}

static void metodo1() {

System.out.println("inicio do metodo1");
metodo2();
System.out.println("fim do metodo1");
}

static void metodo2() {

System.out.println("inicio do metodo2");
int[] array = new int[10];
for(int i = 0; i <= 15; i++) {
array[i] = i;
System.out.println(i);
}
System.out.println("fim do metodo2");
}
}

2
 03/11/2008

6.1 – Fundamentos (cont)

Em Java, o tratamento de exceção e feito por:

try: o trecho de código a ser monitorado;

catch: bloco de código, caso a exceção ocorra;

finally: bloco de código que precise ser

executado antes de sair de um método onde

ocorreu uma exceção.

throw: gera manualmente uma exceção;

throws: exceção a ser gerado por um método;

6.2 - Tratamento de Exceções

Sequencia de execução try-catch-finally

try

sim
erros catch

não

finally

3
 03/11/2008

6.3 try-catch

Sintaxe:
try{
//bloco de código monitorado
}
catch(ExcecaoTipo1 exObj){
//tratamento da exceção do tipo1
}
catch(ExcecaoTipo2 exObj){
//tratamento da exceção do tipo2
}
o o o
catch(ExcecaoTipo exObj){
//tratamento da exceção do tipoN
}
finally{
//código executado antes de sair do bloco
}

6.3 try-catch (cont)

Vamos alterar o programa anterior para o

código abaixo:
try {
for(int i = 0; i <= 15; i++) {
array[i] = i;
System.out.println(i);
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("erro: " + e);
}

4
 03/11/2008

6.3 try-catch (cont)

Agora altere para esta forma :

for(int i = 0; i <= 15; i++) {
try {
array[i] = i;
System.out.println(i);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("erro: " + e);
}
}

Qual a diferença ?

6.4 Tipos de Exceção

Superclasse de exceção: Throwable.

Subclasses que dividem as exceções em duas
ramificações distintas:

Exception

É utilizada para definir condições excepcionais que os
programas devem tratar.

São as exceções criadas pelos usuários.

Error

Define as exceções que, sob condições normais, não
espera-se que sejam identificadas pelo programa.

As exceções deste ramo são utilizadas pela JVM para
indicar erros relacionados ao ambiente de execução.

5
 03/11/2008

Parte da Hierarquia da Classe Throwable

6.5 – Exceções de RunTime

RuntimeException ocorrem durante

a execução e não são obrigadas,
podemos citar:

ArrayIndexOutOfBoundsException

NullPointerException

ArithmeticException

6
 03/11/2008

6.5 – Exceções de RunTime mais comuns

O exemplo abaixo oferece o tratamento caso ocorra um erro de divisão

por zero. Isto é feito monitorando à exceção ArithmeticException.
public class ExcecaoTryCatch {
static public void main (String args[]) {
//Declaração e inicialização de duas variáveis
int i, a;

for(i=5; i>=0;i--){
try{
System.out.print("Dividindo 20 por " + i + "...");
a = 20/i;
System.out.println("20/" + i + "=" + a);
}
catch(ArithmeticException e){
//verifica a divisão por zero
System.out.println("Erro: divisao por zero");
}
}
} //fim do método main
} //fim da classe

6.5 – Exceções de RunTime mais comuns –

Exemplo 2
public class ExercicioExcecao2 {
static public void main (String args[]) {

//Declaração e inicialização de duas variáveis

int i;
int a[] = new int[5];

for(i=0; i<=10;i++){
try{
a[i]=i*2;
System.out.print("a["+i+"]="+a[i]+"\n");

}
catch(ArrayIndexOutOfBoundsException e){
//Tratamento da Exceção
System.out.println("\n\nErro: Tentou acessar uma posicao no
vertor inexistente");
}
}
} //fim do método main
} //fim da classe

7
 03/11/2008

6.5 – Outro tipo de exceção: Checked Exceptions

Tente rodar este programa:

public class TestaExcecoes {

public static void main(String[] args) {

new java.io.FileReader("teste.txt");
}
}

unreported exception java.io.FileNotFoundException; must be caught

or declared to be thrown new java.io.FileReader("teste.txt");

6.5 – Outro tipo de exceção: Checked Exceptions

Existem alguns método no Java onde quem invoca

o método deve tratar o erro. Neste caso podemos
solucionar o problema assim:
public class TestaExcecoes2 {

public static void main(String[] args) {

try {
new java.io.FileReader("teste.txt");
} catch (java.io.FileNotFoundException e){
System.out.println("Arquivo na existe");
}
}
}

8
 03/11/2008

6.5 – Outro tipo de exceção: Checked Exceptions

Ou assim :
public class TestaExcecoes {

public static void main(String[] args) throws

java.io.FileNotFoundException
{
new java.io.FileReader("teste.txt");
}
}

Será que resolvi 100% ?

6.6 – Cláusula throws

Lista as exceções que podem ser

disparadas por um método
tipoDoMétodo nomeDoMétodo( listaDeParametros )
throws ExceçãoTipo1, ExceçãoTipo2,…
{
// corpo do método
}

Declare as execeções do método

através do throws

9
 03/11/2008

6.7 – Tratando mais de um erro

Com o try e catch:

try {
objeto.metodoQuePodeLancarIOeSQLException();
} catch (IOException e) {
// ..
} catch (SQLException e) {
// ..
}

6.7 – Tratando mais de um erro (cont)

Com o throws:
public void abre(String arquivo) throws IOException,
SQLException {
// ..
}

Pode-se tratar algumas exceções e declarar as
outras no throws:
public void abre(String arquivo) throws IOException {
try {
objeto.metodoQuePodeLancarIOeSQLException();
} catch (SQLException e) {
// ..
}
}

10
 03/11/2008

6.8 – Lançando uma Exceção

A instrução throw

é executada para indicar que uma exceção
ocorreu (isto é, um método não pode ser
completado com sucesso)

O operando de um throw pode ser de qualquer
classe derivada de Throwable

A diretiva throw lança um erro, para que um
bloco catch o capture e faça o tratamento
necessário.

Sintaxe:

throw instância_de_uma_exceção;

6.8 throw (exemplos)

Utilizando o método saca da classe ContaCorrente

void saca(double valor){

if (this.saldo < valor){
throw new RuntimeException();
} else {
this.saldo-=valor;
}
}

A exceção RuntimeException é mais generica.

11
 03/11/2008

6.8 throw (exemplos) (cont)

A exceção IllegalArgumentException é mais

indicada para erros com números negativos
e neste caso é mais indicada. Então o
método fica desta foma:

public void saca(float valor){

if (saldo < valor){
throw new IllegalArgumentException("Saldo
Insuficiente");
} else {
saldo-=valor;
}
}

6.8 throw (exemplos) (cont)

O programa principal pode ser assim:

ContaCorrente cc = new ContaCorrente();

cc.deposita(50);
try {
cc.saca(100);
} catch (IllegalArgumentException e) {
System.out.println(“Não pode sacar");
}

12
 03/11/2008

6.9 – Usando printStackTrace e getMessage

Método printStackTrace

Imprime a pilha de chamada de método .

Auxilia no processo de teste e depuração do programa

Método getMessage

Devolve um string descritivo armazenado em uma
exceção.

O método getMessage() definido na classe Throwable
(mãe de todos os tipos de erros e exceptions) vai
retonar a mensagem que passamos ao construtor da
IllegalArgumentException.

6.9 Usando printStackTrace e getMessage

O programa principal pode ser assim:

ContaCorrente cc = new ContaCorrente(50.00f);

try {
cc.saca(100);
} catch (RuntimeException e) {
System.out.println(e.getMessage());
}

13
 03/11/2008

6.10 – Criando a sua própria Exceção

Podemos criar a nossa própria classe de

exceção. Observe o exemplo abaixo:

public class SaldoInsuficienteException extends

RuntimeException {

public SaldoInsuficienteException(String message) {

super(message);
}
}

6.10 – Criando a sua própria Exceção (cont)

Na classe ContaCorrente o método saca fica

assim:
public void saca(float valor){
if (saldo < valor){
throw new SaldoInsuficienteException("Saldo
Insuficiente. Tente um valor menor.");
} else {
saldo-=valor;
}
}

O programa principal não é alterado.

14
 03/11/2008

6.11 - finally

Java garante que o bloco finally (se houver

um) será executado independentemente de
qualquer exceção ser ou não disparada no
bloco try correspondente ou quaisquer de
seus blocos catch correspondentes.

Java também garante que o bloco finally
será executado se um bloco try for
encerrado com uma instrução return, break
ou continue.

public class ExcecaoFinally {

static void metodoA() throws IllegalAccessException{
try{
System.out.println("dentro do metodo A");
throw new RuntimeException("finally");
public static void main(String args[]) {
}
finally{ try{
System.out.println("dentro de finally do metodo A"); metodoA();
} }
} catch(Exception e){
static void metodoB(){ System.out.println("Excecao identificada");
try{ }
System.out.println("dentro do metodo B");
metodoB();
return;
} metodoC();
finally{ } //fim do método main
System.out.println("dentro de finally do metodo B"); } //fim da classe
}
}
static void metodoC(){
try{
System.out.println("dentro do metodo C");
}
finally{
System.out.println("dentro de finally do metodo C");
}
}

15
 03/11/2008

4 public class UsingExceptions {

5
6 // execute application
7 public static void main( String args[] )
8 {
9 // call method1
10 try {
11 method1();
12 }
13
14 // catch Exceptions thrown from method1
15 catch ( Exception exception ) {
Informação do erro
16 System.err.println( exception.getMessage() + "\n" ); gerada pelo
17 exception.printStackTrace(); getMessage e
18 } printStackTrace
19 }
20
21 // call method2; throw exceptions back to main
22 public static void method1() throws Exception
23 {
24 method2();
25 }
26
27 // call method3; throw exceptions back to method1
28 public static void method2() throws Exception
29 {
30 method3();
31 }
32

33 // throw Exception back to method2

34 public static void method3() throws Exception
35 {
36 throw new Exception( "Exception thrown in method3" );
37 } Throw dispara uma
38 Exception que é
39 } // end class Using Exceptions propagada de volta ao
main
Exception thrown in method3

java.lang.Exception: Exception thrown in method3

at UsingExceptions.method3(UsingExceptions.java:36)
at UsingExceptions.method2(UsingExceptions.java:30)
at UsingExceptions.method1(UsingExceptions.java:24)
at UsingExceptions.main(UsingExceptions.java:11))

16
 03/11/2008

Exercicios

1. Inclua um tratamento de exceção na classe

ContaCorrete para que nos métodos de
depositar e sacar, seja feita uma verificação de
valores negativos. Se eles acontecerem uma
exceção deve ser lançada.
2. Crie uma classe ValorInvalidoException para
tratar fazer o mesmo que o exercicio 1.
3. Melhore a ValorInvalidoException colocando um
construtor e recebendo como parâmetro valor
inválido. Sobrescreva o método getMessage
para retorna a mensagem “o valor X é um
número negativo. Informe outro valor”

17