Tratamento de Exceções

Tratamento de Exceções
Uma exceção é um evento que ocorre durante a execução de uma aplicação e que interrompe o fluxo normal das instruções. Muitos tipos de erros podem causar exceções, tais como erros de hardware (um disco rígido com problemas) ou software (uso de um vetor sem posições adicionais, por exemplo). Em ambos os casos, a plataforma Java gera uma exceção que pode ser tratada em tempo de execução pelo software.
Muitas classes da API Java apresentam um tratamento especial que disponibiliza as exceções para que sejam tratadas pelo desenvolvedor. Para saber mais sobre exceções, a forma mais simples é a observação, dentro de um help ou da documentação da API Java (www.javasoft.com/docs), se cada método de uma classe disponibiliza uma ou mais exceções para serem tratadas. Um exemplo disso é a classe System do pacote java.lang. Essa classe tem um atributo in (do tipo InputStream). Quando se executa um System.in.read*(), essa chamada disponibiliza uma exceção de entrada/saída conhecida como IOException, que pode ser tratada.
Manipulando Exceções
Excecao1.java

public class Excecao1 extends Object
{
    public static void main(String args[])
    {
        byte dado[] = new byte[10];
        System.out.println("Digite um número");
        System.in.read(dado);
    }
}

Ao tentar compilar o exemplo acima será gerado o erro de compilação abaixo:

C:\jdk1.2.1\samples\excecao>javac Excecao1.java
Excecao1.java:7: Exception java.io.IOException must be caught, or it must be declared in the throws clause of this method.

          System.in.read(dado);
                        ^
1 error

O erro de compilação acima demonstra haver uma exceção que precisa ser obrigatoriamente tratada. Trata-se, neste caso, de uma exceção de entrada e saída (IOException), como se pode observar pela linha gerada: `

Excecao1.java:7: Exception java.io.IOException must be caught, or it must be declared in the throws clause of this method.

Para saber qual linha de código gerou o erro de compilação, basta analisar a saída gerada pela compilação. Essa saída apresenta o nome do arquivo que contém o erro, seguido de dois pontos e do número da linha de código que apresenta erro.
Após descobrir qual linha apresenta erro, deve-se analisar qual a natureza do erro. Todo erro que diz "... must be caught, or it must be declared in the throws clause of this method" está se referindo a uma exceção que não foi manipulada corretamente. Na linha 7 do exemplo Excecao1.java há o código abaixo:

System.in.read(dado);

Após saber qual o código, a melhor forma de agir é recorrer à documentação do objeto utilizado. Ao encontrar a documentação, pode-se checar o método que está sendo chamado. A documentação dos pacotes disponíveis no J2SDK pode ser obtida no site JavaSoft (www.javasoft.com/docs). No caso acima demonstrado, ao acessar a documentação deve-se inicialmente procurar pela classe System, que se encontra disponível no pacote java.lang. Ao observar o atributo in (System.in), percebe-se que é um objeto do tipo InputStream. Nesse caso, deve-se acessar a documentação da classe InputStream. A lista de exceções geradas pelo método em caso de erros se encontra no método read dessa classe. A partir desse momento, basta tratar as exceções que o método gera. Neste exemplo, a exceção gerada é do tipo IOException.
Como tratar esses erros?
Para tratar as exceções, a linguagem Java disponibiliza a estrutura de controle try-catch-finally, que é utilizada para o tratamento de exceções e fluxo de execução de sua aplicação. O try-catch-finally permite tratar determinado tipo de exceção gerada por um método qualquer. O exemplo a seguir mostra o tratamento de uma exceção de entrada e saída (IOException). Utilizaremos apenas o try-catch, sem o finally:
Excecao1.java

public class Excecao1 extends Object
{
    public static void main(String args[])
    {
        byte dado[] = new byte[10];
        System.out.println("Digite um número");
        try
        {
       // tenta executar o código contido no try,
       // caso haja exceção chama o catch responsável
      // pela exceção
            System.in.read(dado);
        }
        catch (java.io.IOException erro_gerado)
        {
        // pode-se tratar a exceção aqui
        }
    }
}

No exemplo acima não são gerados erros de compilação, pois a classe System contém tratamento da exceção gerada pelo método read do indentificador in, que é do tipo InputStream. Tratar exceções é uma técnica de programação muito recomendada para oferecer uma boa interface para os usuários dos sistemas, por isso a linguagem Java obriga o desenvolvedor a adotar esta prática.
Pode-se utilizar o finally na mesma estrutura do try-catch. Após tratar determinada exceção com o try-catch, o finally possibilita a execução de um bloco qualquer de código. O finally é sempre executado, mesmo que nenhuma exceção tenha sido gerada. Por exemplo, pode-se executar uma operação qualquer sobre o dado lido através da chamada System.in.read().
Exc1.java

public class Exc1 extends Object
{
    public Exc1()
    {
                System.out.println("Chamei o construtor vazio");
    }
    public void lendo()
    {
        System.out.println("Digite um número e tecle ENTER" );
        try
        {
            int i = System.in.read();
        }
        catch (Exception e)
        {
                // tratando a exceção
                System.out.println("Entrando no tratamento de exceção");
        }
        finally
        {
                // executa este bloco de
                //código após tratar a exceção
                System.out.println("O finally é sempre executado após try com ou sem catch");
        }
    }
    public static void main (String args[])
    {
        Exc1 x = new Exc1();
        x.lendo();
    }
}

Exc2.java

public class Exc2 extends Object {

    public static void main(String args[])
    {
        try
        {
            int a[] = new int[2];
            System.out.println(a[4]);
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
                // tratamento da exceção imprime a
                //mensagem que causou a exceção
                System.out.println("Exceção gerada: " + e.getMessage());
                System.out.println("\nPilha de erros");
                // imprime a pilha de erros gerados
                e.printStackTrace();
        }
        finally
        {
  System.out.println("O finally é sempre executado");
        }
}

Com isso, chegamos ao fim do nosso curso introdutório à linguagem Java. Esperamos que tenham gostado! Mas o assunto ainda não está esgotado, e voltaremos a abordar esta fascinante linguagem de programação em futuras edições da Revista do Linux. Até a próxima!
Pra saber mais: 
Java: www.javasoft.com