segunda-feira, 4 de julho de 2011

Excessões em java

-->
Introdução


Quando começamos fazer programas de computadores um problema que surge são erros imprevistos em tempo de execução. Tais erros são conhecidos como exceções que podem ser provenientes erros de lógica ou acesso dispositivos externos.

Abaixo segue o exemplos de algumas possíveis causas de exceções:

Alguns possíveis erros externos:

    • Tentar abrir um arquivo que não existe.
    • Tentar fazer consulta a um banco de dados que não está disponível.
    • Tentar escrever em um arquivo algo em um arquivo que não tem permissão de escrita.



Alguns possíveis erros de lógica:
    • Tentar manipular um objeto que está com o valor nulo.
    • Dividir um número por zero.
    • Tentar manipular um tipo de dado como se fosse outro.
    • Tentar utilizar um método ou classe não existe.


Para tentar fazer o programa desviar de tais imprevistos e necessário tratar essas exceções.


Tratando Exceções

Em java para tratar exceções são utilizados os comandos try e catch.

A sintaxe básica é:

try{

//trecho de código que pode vir a lançar uma exceção

} catch(tipo_exceçao_1 e)
{
//ação a ser tomada
}

catch(tipo_exceçao_2 e)
{
//ação a ser tomada
}
catch(tipo_exceçao_n e)
{
//ação a ser tomada
}


Explicação:


Bloco try{ … } - Neste bloco é introduzido todos codigo de código que poder vir lançar uma exceção.
Bloco catch(tipo_excessao e) { … } - Trecho que captura a exceção tipo_exceçao. Neste bloco descrito a ação que ocorrera quando a a exceção for capturada.


Exemplicando uma exceção


Imagine uma classe que tem um método principal main que tem como seu único objetivo é alterar todas as letras de um frase para maiuscula utitilizando o metodo toUpperCase() da classe String, caso a frase esteja nula e se tente usar o método toUpperCase() na mesma será lançada uma exceção de NullPointerException.



Primeiro vamos ver como ficaria a tal classe sem a utilização do try/catch.

/***
*
* @author Robson Fernando Gomes
*
*/
public class aumentaFrase {

public static void main(String args[])
{
String frase = null;
String novaFrase = null;
novaFrase = frase.toUpperCase();
System.out.println("Frase antiga: "+frase);

System.out.println("Frase nova: "+novaFrase);
}
}


Quando este código fosse executado o mesmo lançaria um NullPointerException, como poder ser visto na saida do console quando executamos tal programa.

Exception in thread "main" java.lang.NullPointerException
at aumentaFrase.main(aumentaFrase.java:15)

Ou seja o mesmo tentou acessar um atributo de um objeto que estava nulo. Para ajudar a melhorar o a situação o uso deve-se usar o try/catch.

/***
*
* @author Robson Fernando Gomes
*
*/
public static void main(String args[])
{
String frase = null;
String novaFrase = null;
try{
novaFrase = frase.toUpperCase();
} catch(NullPointerException e) //CAPTURA DA POSSÍVEL exceção.
{
//TRATAMENTO DA exceção

System.out.println("O frase inicial está nula, para solucional tal o problema, foi lhe atribuito um valor default.");

frase = "Frase vazia";
novaFrase = frase.toUpperCase();
}
System.out.println("Frase antiga: "+frase);

System.out.println("Frase nova: "+novaFrase);
}
}

Quando este código fosse executado o mesmo lançaria um NullPointerException, porém esta exceção será tratada desta vez, sendo a mesma capturada pelo catch{} e dentro deste bloco as devidas providências são tomadas, neste caso é atribuido um valor default a variavel frase. A saida deste programa seria a seguinte:

O frase inicial está nula, para solucional tal o problema, foi lhe atribuito um valor default.
Frase antiga: Frase vazia
Frase nova: FRASE VAZIA

Comando finally

Imagine a seguinte situação, foi aberta uma conexão com o banco de dados para realizar deteminada ação, e no meio deste processo seja lançada alguma exceção, como por um exemplo NullPointerException ao tentar manipular um determinado atribuito de um objeto, a conexão até o momento com o banco de dados não seria fechada resultando desta maneira em conexão, sem que nenhuma ação fosse tomada para fechar tal conexão, neste caso seria necessário que mesmo sendo lançada uma exceção no meio do processo a conexão deve ser fechada. Um outro exemplo bom seria abertura de determinado arquivo para escrita no mesmo, e no meio deste processo é lançada uma exceção por algum motivo, o arquivo não seria fechado, o que resultaria em deixa o arquivo aberto.
Quando uma exceção é lançada e é necessário que determinada ação seja tomada mesmo após a captura de uma exceção utilizamos a palavra reservada finally.

Sintaxe:

try{
//trecho de código que pode vir a lançar uma exceção
}
catch(tipo_exceçao_1 e)
{
//ação a ser tomada
}

catch(tipo_exceçao_2 e)
{
//ação a ser tomada
}
catch(tipo_exceçao _n e)
{
//ação a ser tomada
}
finally{
//ação a ser tomada
}


Exemplo:

/***
*
* @author Robson Fernando Gomes
*
*/
public class aumentaFrase {

public static void main(String args[])
{
String frase = null;
String novaFrase = null;
try{
novaFrase = frase.toUpperCase();
} catch(NullPointerException e)
{
System.out.println("O frase inicial está nula, para solucional tal o problema, foi lhe atribuito um valor default.");
frase = "Frase vazia";
}
finally
{
novaFrase = frase.toUpperCase();
}
System.out.println("Frase antiga: "+frase);

System.out.println("Frase nova: "+novaFrase);

}
}

Quando este código fosse executado o mesmo lançaria um NullPointerException, porém esta excessã o será tratada desta vez, sendo a mesma capturada pelo catch{} e dentro deste bloco as devidas providências são tomadas, neste caso é atribuido um valor default a variavel frase. Neste exemplo mesmo o código lançando uma exceção durante a sua execução e a mesma sendo capturada pelo catch, uma determinada ação será tomada no bloco finally, neste caso tanto com a exceção ou não será executada a linha “ novaFrase = frase.toUpperCase();”, tornando todas letras da frase maiuscula. A saida deste programa seria a seguinte:

O frase inicial está nula, para solucional tal o problema, foi lhe atribuito um valor default.
Frase antiga: Frase vazia
Frase nova: FRASE VAZIA


-->
Comando throw e throws

Imagine uma situação que não é desejado que uma exceção seja tratada na própria classe ou método, mas sim em outro que venha lhe chamar. Para solucionar tal situação utilizandos o comando throws na assinatura do método com a possível exceção que o mesmo poderá a vir lançar.



Sintaxe:



tipo_retorno nome_metodo() throws tipo_exceção_1, tipo_exceção_2, tipo_exceção_n

{


}



Exemplo:


/***
*
* @author Robson Fernando Gomes
*
*/
public class TesteString {

private static void aumentarLetras() throws NullPointerException //lançando excessão
{
String frase = null;
String novaFrase = null;
novaFrase = frase.toUpperCase();
System.out.println("Frase antiga: "+frase);

System.out.println("Frase nova: "+novaFrase);
}
public static void main(String args[])
{
try
{
aumentarLetras();
}
catch(NullPointerException e)
{
System.out.println("Ocorreu um NullPointerException ao executar o método aumentarLetras() "+e);
}
}
}


Neste exemplo será lançada uma exceção no método aumetarLetras():

private static void aumentarLetras() throws NullPointerException “

E o mesmo será tratado no método main().
...

try
{
aumentarLetras();
}
catch(NullPointerException e)
{
System.out.println("Ocorreu um NullPointerException ao executar o método aumentarLetras() "+e);
}



Saida:

Ocorreu um NullPointerException ao executar o método aumentarLetras() java.lang.NullPointerException




Agora imagine o caso que seja necessário lançar uma exceção padrão ao invés uma especifica, para resolver este problemas utilizamos o comando throw dentro do bloco do catch que desejamos converter a exceção.

Sintaxe:

try{
}
catch(tipoExcessão_1 e)
{
throw new novoTipoExceçao(e);
}



Exemplo:


/***
*
* @author Robson Fernando Gomes
*
*/
public class TesteString {

private static void aumentarLetras() throws Exception //lançando excessão
{
String frase = null;
String novaFrase = null;
try{
novaFrase = frase.toUpperCase();
}catch(NullPointerException e)
{
throw new Exception(e);
}
System.out.println("Frase antiga: "+frase);

System.out.println("Frase nova: "+novaFrase);
}
public static void main(String args[])
{
try
{
aumentarLetras();
}
catch(Exception e)
{
System.out.println("Ocorreu uma exceão ao executar o método aumentarLetras() "+e);
}
}
}



Neste exemplo será lançado um NullPointerException e o mesmo será convertido para Exception e relançado como Exception no método aumentarLetras() e por final o mesmo é tratato no método main().


Saida:

Ocorreu uma exceão ao executar o método aumentarLetras() java.lang.Exception: java.lang.NullPointerException


 


Nenhum comentário:

Postar um comentário