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