O conceito de uma exceção em programação é quando algo não ocorre conforme o desejado, logo é iniciado (ou não dependendo da previsão do desenvolvedor) um processo / programa. Em Java há recursos para que essas
exceções sejam devidamente tratadas nas cláusulas
TRY / CATCH / FINALLY. Sugerindo a classe abaixo:
package br.com.excecoes.everton;
public class Telefone{
public String returnDDD(String str){
return str.substring(0, 3);
}
}
Esse método retornaria o prefixo do telefone, ou seja, os três primeiros dígitos. É importante ressaltar que esse método funcionaria, embora não seja tratado o tipo de informação que está sendo passada por parâmetro, isto é, se esse método receber "null", será lançado uma
NullPointerException; se for recebido uma string vazia, a exibição para o usuário final seria
StringIndexOutOfBoundsException, convenhamos para um usuário final, é uma situação altamente desagradável receber esse tipo de mensagem na tela do sistema. Vamos aplicar boas práticas de orientação a objetos, cada método deve assumir a responsabilidade pela validação dos dados que recebe. No código a seguir, serão efetuadas algumas revisões no método returnDDD lançando exceções:
public class Telefone {
public String returnDDD(String str) throws Exception{
if(str==null){
throw new IllegalArgumentException("Parâmetro nulo");
}else if(str.length() < 3){
throw new IllegalArgumentException("Tamanho do parâmetro tem que ser maior do que 3");
}
try{
int prefixo = Integer.valueOf(str.substring(0, 3));
}catch(NumberFormatException numEx){
throw new NumberFormatException("Prefixo tem que ser um número");
}
return str.substring(0, 3);
}
}
Revisado o código, a informação recebida é devidamente tratada. Caso seja recebido um valor null para o texto, será lançado uma NullPointerException; caso venha uma string vazia a exibição será StringIndexOutBoundsException. Em ambos situações ocorrem bugs do método returnDDD, sendo que não deveriam acontecer em nenhuma circunstância. Por isso foram criadas exceções mais específicas para que o sistema tenha o mínimo de respostas amigáveis. No caso do nosso método, são tratados mais exceções, como por exemplo o tamanho mínimo da string e se realmente é um valor numérico.
Abaixo temos a classe main que faz a chamada da classe Telefone:
public class ExcecoesJava {
public static void main(String[] args) {
Telefone fone = new Telefone();
try{
System.out.println("O prefixo do telefone eh: " +
fone.returnDDD("12"));
}catch(IllegalArgumentException ex){
System.out.println(ex.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
Vamos verificar algumas mensagens de acordo aos parâmetros passados:
- parâmetro "011-55556666", a resposta seria: O prefixo do telefone eh: 011;
- parâmetro null, a resposta seria: Parâmetro nulo;
- parâmetro "12", a resposta seria: Tamanho do parâmetro tem que ser maior do que 3.
Os parâmetros e respostas em "vermelho", seriam condições negativas, ou seja, erros que seriam passados como parâmetros, embora devidamente tratados por nosso programa.
SequênciaSempre trate as exceções pela sua respectiva hierarquia, note que no nosso método a última exceção lançada é a
Exception, por ser a mais genérica.
ConclusãoO artigo descrito anteriormente teve o intuito de abordar alguns pontos interessantes sobre manipulação de exceções, obviamente existem mais a ser estudado - melhorar os conceitos sempre nos ajuda a entender melhor o mecanismo de tratamento fornecido pelo Java. É importante ressaltar que por mais trabalhoso que aparente, é fundamental o devido tratamento dos erros. Certamente, o projeto será mais robusto, tendo o cuidado de lidar com os erros de forma mais específica, em uma linguagem que possue um mecanismo de tratamento de erros altamente sofisticado.
