Tutorial Manipulando erros com try catch finally ( Linux )

[USERM4N]

Este artigo mostra que o Java traz características interessantes para a programação, como suas técnicas de manipulação de erros, que muitas vezes em outras linguagens nos levam a criar códigos extensos para tornar um software mais robusto.
Por: Ygor Thomaz

Objetivo do artigo
Este artigo mostra que o Java traz características interessantes para a programação. Como suas técnicas de manipulação de erros, que muitas vezes em outras linguagens nos levam a criar códigos extensos para tornar um software mais robusto.

Introdução necessária:

* tipos de dados
* variáveis
* operadores
* estruturas de controle (trataremos sobre a de controle de erros aqui)

Características da linguagem Java
Pelo caráter introdutório coloco aqui algumas informações importantes sobre a utilização do Java.

São inúmeros os benefícios que a linguagem Java oferece.

* orientada a objeto;
* robusta e segura;
* independente de plataforma.

Quem está usando JAVA?

* serviços financeiros;
* comércio seguro, acesso a bases de dados a partir da Web, carga de dados dinâmicos;
* vendas e propaganda;
* animações 3D interativas, integração síncrona entre imagens e audio;
* educação;
* ensino à distância, simulações interativas.

Alguns pontos fracos do Java:

* um sistema operacional pode oferecer recursos que o Java não consegue interpretar sem sacrificar a compatibilidade multiplataforma;
* o byte Java interpretado não roda com a mesma velocidade do código nativo compilado;

Estruturas de controle de erros
O Java oferece duas importantes estruturas de erros, o try catch e try catch finally.

Elas tem como objetivo separar o código que trata rotinas de manipulação de erros, além de evitar que o programador passe horas desenvolvendo testes de verificações e avaliações de erros antes de executar certa operação.

Através destas diretivas evidenciamos o que será monitorado automaticamente pelo JVM*.

A ocorrência destes erros serão sinalizados pelas exceções. Objetos com informações sobre o tipo de erro detectado. A partir deste momento já se pode começar ter a idéia de quanto pode ser útil a utilização destas estruturas. Existem diversas categorias de exceções e cada pacote utilizado pelo programa traz exceções específicas.

Obs: nossas exceções podem ser desenvolvidas, ampliando as opções no tratamento de erros.

Vamos colocar a utilização das estruturas de erros em testes práticos.

try catch
Aplicação com teste convencional de manipulação de erros:

public class ExemploTeste {
  public static void main (String args[]) {
    if (args.length > 0) {
      int j = Integer.parseInt(args[0]);
      while (j >= 0) {
        System.out.println(j);
        j-;
      }
    }
    else {
      System.uot.println("Falta um argumento inteiro");
    }
  }
}

Aplicação com teste convencional de manipulação de erros:

public class ExemploTeste {
public static void main (String args[]) {
if (args.length > 0) {
int j = Integer.parseInt(args[0]);
while (j >= 0) {
System.out.println(j);
j-;
}
}
else {
System.uot.println("Falta um argumento inteiro");
}
}
}

O problema com a quantidade de argumentos foi solucionado, embora o programa tenha ficado extenso. Agora imaginemos que o argumento fornecido não seja um inteiro, por exemplo, um caracter 'x', acontecerá a sinalização de uma outra exceção (NumberFormatException).

Isso vai gerar erro no momento da compilação do código devido a tentativa de conversão do argumento para um inteiro. Daí percebe-se que o código acima deverá ser implementado para contornar esta situação. É neste ponto de vista que se torna necessário o uso da diretiva try catch, que se mostra mais vantajosa.

Aplicação da diretiva try catch:

//ExemploTryCatch.Java
public class ExemploTryCatch {
  public static void main (String args[]) {
    try {
     int j = Integer.parseInt(args[0]);
      while (j >= 0) {
        System.out.println(j);
        j--;
      }
    }
    catch (Exception e) {
      System.out.println("Nao foi fornecido um argumento ou o mesmo não"+
      " é valido");
    }
  }
}

Analisando partes:

try {
Inicia o bloco no qual o conteúdo é tratado pela cláusula catch.

catch (Exception e) {
Aqui utilizamos uma exceção genérica Exception, qualquer erro surgido no trecho de código delimitado pelo bloco try é tratado pela rotina delimitada pela cláusula catch.

try catch finally
Existe a possibilidade de adicionarmos a cláusula finally à diretiva try. A mesma tem como função tornar obrigatório dentro do bloco delimitado pelo try a execução do trecho contido na cláusula finally. Colocando em código o que foi dito, ficaria algo assim :

  try {
    diretiva_normal;
  }
  finally {
    diretivo_de_execucao_garantida;
  }

Um programa com a utilização básica do try catch finally seria o exemplo dado logo abaixo.

Aplicação da diretiva try catch com finally:

 public class error {
    public static void main (String args[]) {
      int j = 5; // Valor default
      try {
        j = Integer.parseInt(args[0]);
      }
      catch (Exception e) {
        System.out.println("Argumento invalido ou ausente. \n" +
        "Usando valor default");
      }
      finally {
        while (j >= 0) {
          System.out.println(j+"\n");
          j--;
        }
        System.out.println("\nEste código faz parte da minha pesquisa sobre" +
        "manipulação de erros em Java. \nCom uso de exceções.");
      }
    }
  }

Ao executar o programa poderemos notar que a execução é sempre exibida, seja com o valor informado ou com valor default. Outro ponto neste programa é que a exibição das mensagens de erros indica uma solução para o problema alertando o usuário que algo será exibido mesmo se ele cometeu algum erro na utilização do programa.

O finally é geralmente usado quando desejamos garantir que certos recursos do sistema serão utilizados independente de como ocorra sua utilização através do usuário.

Finalizando
Links e Referências:

JVM : Java Virtual Machine
Site:
Apenas usuários registrados e ativados podem ver os links., Clique aqui para se cadastrar...

Fonte: vivaoLinux
Postado Por: RedDeviL