EXCEÇÕES
Classe
Java possui algumas propriedades particulares, a saber:
Exceções são instâncias de classes que pertencem à hierarquia de classes que inicia em Throwable, classe estendida por Error e Exception, de acordo com a figura.
Em especial, a classe Error é a base para erros não-verificados enquanto Exception é a base para as exceções verificadas. Já a classe RuntimeException é a base para exceções em tempo de execução.
Exceções
Durante a execução de uma aplicação, cada chamada a um método é colocada em uma pilha de ativação. Quando ocorre uma exceção em um dado método, o mecanismo de tratamento de exceções é ativado para desempilhar as chamadas a métodos da pilha até encontrar um bloco que trate aquela exceção, de modo que a aplicação seja executada, conforme esperado. Porém, caso tal bloco não seja encontrado, a execução da aplicação é encerrada.
Para capturar exceções, usa-se o bloco try-catch. No bloco try, é incluido o código a ser executado e protegido contra exceções. Na ocorrência de uma exceção dentro do bloco try, a execução é interrompida e desviada para o bloco catch correspondente ao tipo de exceção. A sintaxe é apresentada a seguir:
try{
// comandos;
}catch(ClasseDeExcecao){
...
}catch(OutraClasseDeExcecao){
...
}
O uso de catch pode ser ampliado em função das necessidades, de modo que podem ser tratados diversos tipos possíveis de exceções (determinados pelas classes de exceção usadas) que possam ocorrer no bloco try.
No exemplo abaixo, exemplifica-se um código que contém o erro referente ao tamanho de um vetor:
1. public Saudacoes{
2.
3. public static void main(String args[]){
4.
5. int i = 0;
6. String saudacoes[] = {"Oi","Olá","Alô"};
7.
8. while(i < 4){
9. System.out.println(saudacoes[i]);
10. i++;
11. }
12. }
13. }
O código exibido imprime na saída-padrão, o conteúdo do array de strings saudacoes, todavia, na linha 8, ao executar o laço, é lançado uma exceção do tipo java.lang.ArrayIndexOutOfBoundsException, uma vez que tenta-se acessar o índice 3 do array, porém o mesmo não existe.
Para resolver o problema, precisa-se capturar a exceção (na verdade, o objeto respectivo) e tratá-lo, de modo que a execução da aplicação saudacoes ocorra sem problemas. O exemplo seguinte exemplifica tal situação:
public Saudacoes{
public static void main(String args[]){
int i = 0;
String saudacoes[] = {"Oi","Olá","Alô"};
while(i < 4){
try{
System.out.println(saudacoes[i]);
i++;
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Erro no indece do Arrays");
break;
}
}
}
}
O código passível de exceções foi incluído no bloco try-catch, fazendo o devido tratamento da exceção. No local marcado, a exceção considerada é um objeto da classe ArrayIndexOutOfBoundsException – e apenas denota qualquer objeto desta classe.
Quando necessita-se liberar recursos previamente alocados, quando há ocorrência de exceções, utilizamos o bloco try-catch-finally, de acordo com a sintaxe seguinte.
try{
// comandos;
// comandos de aquisição de recursus do sistemas
}catch(ClasseDeExcecao){
...
}catch(OutraClasseDeExcecao){
...
}finally{
// comandos que liberam Recursoss
}
Em termos práticos, finally é opcional, no entanto, independente da ocorrência ou não de exceções dentro do bloco try-catch, o bloco finally será executado. A seguir será exemplificado tal caso:
public Saudacoes{
public static void main(String args[]){
int i = 0;
String saudacoes[] = {"Oi","Olá","Alô"};
while(i < 4){
try{
System.out.println(saudacoes[i]);
i++;
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("Erro no indece do Arrays");
break;
}finally{
System.out.println("Sempre sera executado");
}
}
}
}
**Independente da ocorrência ou não da exceção, a parte referente ao finally será executada.**
Lançamentos de Exceções
Uma exceção é lançada quando ocorre uma condição adversa na execução de uma dada aplicação, de modo que a execução do método atual é suspensa, sendo lançado o objeto exceção para o bloco catch subsequente na pilha de ativação.
Usando throws determina-se que um método pode lançar exceções dos tipos, em sequência, especificados. Lembramos apenas que throws lançam objetos (novos ou capturados em um bloco catch) de uma subclasse de Throwable.
Exemplifica-se o lançamento de exceções, em seguida.
1. void metodo() throws ArithmeticException{
...
}
2. String outroMetodo(int valorInt) throws MinhaExcecao, IOException{
...
}
Na linha 1, o método metodo() lança exceções do tipo ArithmeticException e na linha 2, o método outroMetodo() lança exceções do tipo MinhaExcecao – que exemplifica uma exceção qualquer desenvolvida pelo programador – e IOException. Ressaltado que após throws pode-se adicionar uma lista de todas as possíveis classes de exceção aplicáveis ao método, separados por vírgula.
Criação de Exceções
Existe o caso em que pode-se criar as próprias exceções. Neste caso, a nova classe de exceção deve ser uma subclasse de Exception (do pacote java.lang) ou de alguma de suas subclasses.
Apresenta-se, a seguir, um esquema simplificado utilizado para declarar a classe MinhaExcecao que estende diretamente Exception.
class MinhaExcecao extends Exception{
public MinhaExcecao(){
super("Um novo tipo de Exceção!!!");
}
}
Observe que usa-se super() para indicar a mensagem Um novo tipo de exceção!!! a ser aplicada ao lançamento de exceções do novo tipo – MinhaExcecao.
Em seguida, apresenta-se os exemplos de como se lançar e capturar a nova classe de exceção criada.
1. class TestaMinhaExcecao{
2. public void metodoTeste(boolean sucesso)throws MinhaExcecao{
3.
4. if(sucesso == false)
5. throw new MinhaExcecao;
6. }
7. }
Na linha 5, é lançada uma exceção do tipo MinhaExcecao, no caso do boolean sucesso for igual a false. Observa-se que para lançar a exceção, usa-se throw new – construção válida para criar novos objetos de qualquer tipo de exceção.
Fazendo a chamada do método metodoTeste() em outra classe.
class UsandoException{
public static void main(String args[]){
TestaMinhaExcecao objeto1 = new TestaMinhaExcecao;
try{
objeto1.metodoTeste(false);
}catch(MinhaExcecao e){
System.out.println(e.getMessage());
}
}
}
Para capturar uma exceção do tipo MinhaExcecao, tem que se fazer a invocação do método metodoTeste(), passando false como argumento. Sendo assim, foi lançada uma exceção, é apresentada então, na saída-padrão, Um novo tipo de exceção!!! Uma vez que utiliza-se o método getMessage() - disponíveis na classe Throwable – que retorna a mensagem utilizada para criar uma exceção (no caso, aquela mensagem passada via super() na classe MinhaExcecao).
Atividade de Fixação
No intuito de fixar a aprendizagem iniciada por meio deste módulo e verificar como está sua compreensão sobre o mesmo, são sugeridos alguns exercícios de fixação para serem resolvidos. Clique no link de exercício ao lado, pois será por meio dele iniciada a lista de exercícios sobre os conteúdos estudados até este momento. Boa revisão sobre os mesmos!!