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

Existem linguagens de programação que contêm mecanismos especiais para tratamentos de exceções; com Java não é diferente e o propósito deste artigo é analisar como isso é feito.

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

Artigos relacionados