Artigos Java Tratamento de Exceções em Java: Desmistificando a Certificação SCJP6 Parte IX - Parte 1

Capturando uma Exception com try e catch

Fique preparado para diversas perguntas no exame que incluam o controle de fluxo como parte do seu código, até mesmo aquelas que não estiverem ali analisando especificamente seu conhecimento sobre o assunto.

A especificação de Java estabelece que “uma exceção será lançada quando restrições semânticas forem violadas”, o que implica que exceção é lançada em situações que são não possíveis ou em violações sérias do comportamento admissível do sistema.

Então, precisamos de um modo de informar a JVM que código efetuar quando determinada exceção acontecer. Para fazer isso, usam-se as palavras-chave try e catch. 

package br.com.devmedia;



import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;



public class ExceptionTratamento {



/**

* @param args

*/

public static void main(String[] args) {

try{

BufferedReader buffer = new BufferedReader(new FileReader("teste.txt"));

}catch (IOException e) {

System.out.println("Arquivo não encontrado "+ "teste.txt");

}



}



}

Um dos grandes benefícios da utilização da manipulação de exceções é que o código de manipulação de alguma exceção específica, que possa acontecer na região controlada, precisa ser escrito apenas uma única vez. 

Bloco (finally)

O bloco finally vai definir o código que sempre será executado em algum local, após do bloco try, se uma exceção for ou não lançada.

Mesmo se acontecer uma instrução return no bloco try, o bloco finally será executado depois dessa instrução. Esse é o ponto ideal para fechar os arquivos, executar qualquer outra rotina de limpeza que seu código necessitar ou liberar os soquetes de rede.

Iremos avaliar o exemplo abaixo.

package br.com.devmedia;

public class X {

static X x1;

static X x2;

static int divisao(int a, int b){

return a/b;

}

/**

* @param args

*/

public static void main(String[] args) {

try{

System.out.println("Try sendo executado.");

x1 = new X();

x2 = new X();

dividir(7,0);

System.out.println("Esse ponto nunca será "+ "execultado");

}catch (ArithmeticException e) {

System.out.println("Catch sendo executado.");

}finally{

System.out.println("Finally sendo executado!");

}

}

}

Saída:
Try sendo executado.
Catch sendo executado.
Finally sendo executado!

O bloco finally não é obrigatório. Além disso, já que o compilador não determina nem mesmo cláusulas catch, em algumas situações você poderá se encontrar com um bloco try seguido imediatamente por um finally.

Veja o exemplo a seguir, de um try sem um catch, mas com um finally. A exceção é lançada, mas mesmo assim o bloco finally é efetuado. 

package br.com.devmedia;

public class Y {

static Y a1;

static Y a2;

static int dividir(int a, int b){

return a/b;

}

/**

* @param args

*/

public static void main(String[] args) {

try{

System.out.println("Try em execução.");

a1 = new Y();

a2 = new Y();

dividir(4,0);

System.out.println("Esse local não será executado");

}finally{

System.out.println("Finally sendo executado!");

}

}

}

Saída:
Try em execucução.
Exception in thread "main" Finally sendo executado!
t1 está sujeito ao coletor de lixo
t2 está sujeito ao coletor de lixo
java.lang.ArithmeticException: / by zero
at br.com.devmedia.Y.dividir(Y.java:10)
at br.com.devmedia.Y.main(Y.java:21)

Não é considerado correto utilizar uma cláusula try sem um catch ou finally. Um try individual causa erro de compilação. Qualquer cláusula catch deve vir imediatamente após o try. Qualquer finally precisa vir imediatamente após a última cláusula catch, ou deve seguir logo após o try, na inexistência de catch.

Na continuação desse artigo trataremos um pouco mais de Exception, suas definições e sua API.

Leia todos artigos da série