domingo, 5 de julho de 2009

Post extends Exception

Voltando a falar de tópicos que são abortados na prova de certificação SCJP. Algumas pessoas já devem ter percebidos que esse post vai ser sobre Exceptions. Nesse assunto não esta só relacionada à prova, qualquer pessoa que já tenha escrito algum sistema, mesmo que seja básico, já deve ter se deparado com esse mecanismo. Vamos ao assunto.
No desenvolvimento de software qualquer desenvolvedor deve ter em mente que em algum momento vai escrever algum que código que terá chance de provocar algum tipo de erro, erros também podem acontecer por causa do hardware. Para que exista uma manipulação eficiente desses erros, a linguagem Java fornece a manipulação de exceções.
Com essa manipulação os desenvolvedores poderão detectar erros e ainda fornece a possibilidade de lida com exceções de diferentes tipos. Mas o que seria uma exceção? É uma ocorrência que altera o fluxo normal do programa.
Existem 3 palavras que estão diretamente relacionada com o tratamento de exceções: TRY, CATCH e FINALLY. Vamos falar dos dois primeiros.
TRY é usado para indicar um bloco de código que poderá gerar alguma exceção, esse bloco é chamado de região protegida. Uma ou mais cláusulas de CATCH (manipuladores de exceção) poderão ser relacionadas para exceções especificas. Exemplo:
try{
//linha 1
//linha 2
}catch(exception1){
// linha 3
} catch(exception2){
// linha 4
}
//linha 5
Nesse pseudocódigo a linha 1 e 2 constituem a região protegida. A linha 3 esta no bloco de catch do tipo exception1, significando que se acontecer alguma exceção na linha 1 ou 2 e a exceção por desse tipo, o código da linha 3 executará. A área que a linha 4 esta é o bloco do catch relativo ao tipo de exception2, então se alguma exceção acontecer no bloco do try (linha 1 e 2) e for do tipo exception2, a linha 4 ira ser executada. Caso alguma exception ocorra no bloco try, a execução vai pular o código restante do bloco e vai começar a executar o bloco catch do tipo da exception e depois passará para a linha 5 e continuar a executar.
Falando agora da terceira palavra relacionada com exceções. FINALLY é um bloco de código que sempre será executado depois do bloco TRY, mesmo se uma exceção for lançada ou não. Caso uma exceção ocorra no bloco try, a execução passar para o bloco catch relacionada a essa exception e depois executará o bloco finally.
try{
// linha 1
// linha 2
}catch(exception1){
//linha 3
}finally{
//linha4
}
Explicando o código. Como antes a execução começar na linha1 do bloco try, caso uma exception ocorra e essa do tipo exception1 então a execução passara para o bloco do catch e depois ira executar o bloco do finally. Caso nenhuma exception ocorra no bloco try, a execução ira direto para o bloco try. Lembrando, finally sempre será executado (existem poucos casos aonde ele não será executado).
Demonstrarei alguns códigos validos e não-validos em relação a try, catch e finally.
try{

}finally{

}
O código acima é valido, um bloco try tem que ter um bloco finally ou pelo menos um bloco catch.
try{

}
System.out.print(“alguma coisa”);
Não é valido, pois não existe nem bloco try e nem catch.
try{
}
System.out.print(“alguma coisa”); // erro aqui
catch{
}
Não pode existe código entre os blocos try e catch.

Irei falar agora da Hierarquia de Exceções.
Toda as classes de exceções são subtipos da classe Exception. Essa classe é subtipo da classe Throwable que é subtipo de Object.
Throwable tem duas classes que são subtipos dela: Exception e Error. As classes que são subtipos de Error, são situações incomuns como memória cheia, por isso é inviável fazer o tratamento essas erros.
Para ter mais informações sobre a exception gerada, existe um método em Throwable que é o printStackTrace que fornece mais informações sobre a exceção que foi lançada. Exemplo:
try{
}catch(Exception e){
e.printStackTrace;
}

Falando agora de blocos de catch. Um bloco catch que tenha referencia a uma exception não pode vim depois um catch que seja maior que essa exception. Exemplo.
try{
}catch(IOException e){
}catch(FileNotFoundException e){
}
Esse código não compila pois a exception FileNotFoundException é um tipo de IOException então não pode vim depois.
Existem dois tipos de exceções, checadas e não-chegadas. Toda exceção que esteja abaixo de Exception é checada, mas RuntimeException não é chegada e é subtipo de Exception. Qualquer evento que esteja abaixo de Error é não checada. E qualquer exceção que seja criada, utilizando extends Exception é checadas.
Métodos que lancem exception do tipo checadas tem que existe em sua discrição uma informação sobre essas exceções, isso é feito através da palavra: THROWS. Exemplo:
public void myFunction() throws IOException, MyExpection{
}
Escrevendo código, é possível lançar exception utilizando a palavra reservada THROW. Exemplo:
public void myFunction2(){
throw new IOException;
}
Um método que esteja chamando outro método que lance exceções checadas deve tratar essa exception (utilizando try e catch) ou relançar essa exception utilizando THROWS. Exemplo:
void doStuff(){ // esse método deve utilizar try e catch ou utilizar throws
doMore();
}
void doMore(){
throw new IOException;
}

Estou acabando esse post (que foi enorme). Exceções é um assunto aparece por toda a prova e é sempre bom estudar um pouco mais. Espero que tenha ajudado com alguma coisa e desculpa de escrevi alguma coisa errada.

Fonte: Livro da Kathy Sierra, Certificação Sun para programador Java 5, guia de estudo.

Um comentário:

  1. Boa garoto! realemnte é um assunto que devemos saber manipular, pois é um caso frequente. boa inciativa!

    ResponderExcluir