Mostrando postagens com marcador exceção. Mostrar todas as postagens
Mostrando postagens com marcador exceção. Mostrar todas as postagens

sexta-feira, 3 de fevereiro de 2012

O que é NullPointerException ?

 

"Quem nunca tomou um NullPointerException atire o primeiro mouse."

Quando uma pessoa começa a caminhar o longo caminho do mundo da programação um erro comum com qual se defronta é com o famoso e não querido NullPointerException, mas o que vem a ser esse obstaculo na vida de um programador e como resolvê-lo ? Para resolver tais estão publiquei essa essa dica que explica de forma bem simples o que é e como resolver um caso simples de NullPointerException.


Como ocorre ?

O NullPointerException ou NullPointer para os mais íntimos ocorre quando tenta-se utilizar um atributo ou método de um objeto que não fora inicializado. (Que esteja no estado null). Um exemplo pode ser visto no código abaixo:


package com.blogspot.maguscode;

public class TesteNullPointer {

   
    public static void main(String args[])
    {
        Carro carro = null;
        carro.setMarca("Gol");
        System.out.println("Marca do carro é:"+carro.getMarca());
    }
}


Quando esse código é executando o resultado é um NullPointerException como pode ser visto na figura abaixo:



 Neste caso o objeto Carro não foi instaciado e seu estado permaneceu nulo, quando foi tentado inserir um valor a seu atributo marca foi lançado um NullPointerException pois o objeto Carro em questão não existia em lugar algum. É como se tenta-se localizar uma casa com um determinado número em uma cidade que não existe.
De grosso modo o NullPointer acontece quando tentamos acessar um atributo em um objeto que não existe.


Como solucionar ?

Uma solução para matar o NullPointer seria verificar se o objeto está instancianciado caso não esteja instancia-lo ou simplismente instância-lo quando o mesmo for criado como no exemplo abaixo:



package com.blogspot.maguscode;

public class TesteNullPointer {

   
    public static void main(String args[])
    {
        Carro carro = new Carro();
        carro.setMarca("Gol");
        System.out.println("Marca do carro é:"+carro.getMarca());
    }


 




 
 

sexta-feira, 8 de julho de 2011

Criar exceções



Assim como qualquer objeto, em java também é possível criar suas próprias exceções. Imagine um cenário que nenhuma exceção existente faça sentido para ser lançada por você. Por exemplo imagine que por algum motivo você precisa que uma exceção seja lançada quando a letra “A” ou “a” não existe e determinada frase, como não existe nenhuma exceção específica para este caso será necessário criar uma exceção.


Criando uma exceção para ser lançada toda vez que uma letra “A” ou “a” não é encontrada em uma determinada frase.

public class SemLetraAException extends Exception {
@Override
public String getMessage() {
return "Não existe letra A em sua frase";
}

}
Toda exceção criada deve estender Exception, neste exemplo foi sobrescrito o método getMessage()
, que é exibida no prompt toda vez que a exceção é lançada.

Utilizando a exceção

Abaixo segue um exemplo que é utilizado a exceção criada acima.

public class TesteExcecao {

public static void main(String args[]) throws SemLetraAException {
String frase = "Sou um teste!";
if(!frase.contains("a") || !frase.contains("A"))
throw new SemLetraAException();
}
}

Quando o programa acima fosse executada uma exceção do tipo SemLetraAException() será lançada, abaixo é está a saida exibida no prompt:

Exception in thread "main" SemLetraAException: Não existe letra A em sua frase
at TesteExcecao.main(TesteExcecao.java:8)

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