exceptions_capture - F4NT0/J4V4 GitHub Wiki

Retornar

Capturando Exceções

Para capturar e tratar exceções, utiliza-se o bloco de comandos try...catch...finally como abaixo:

try
{
 //código que pode gerar exceções
}
catch(Exception e)
{
 //código que trata exceção
}
finally
{
 //tratamento geral
}
  • try{}: Estão colocados os comandos que podem provocar o lançamento de uma exceção.
  • catch{}: É o bloco que trata das exceções do try, podem ser capturados em mais de um catch ao mesmo tempo.
  • finally(): É onde contém o código a ser executado, independente dos outros comandos, é opcional, mas quando presente é sempre executado, não importa o que aconteca no código.

Como funciona a Captura

A captura funciona da seguinte forma: Uma vez lançada, uma exceção capturada no bloco try procura por uma cláusula catch capaz de referência-la e tratá-la. Se não houver, o programa irá parar com erro.

Uma cláusula catch pode referenciar qualquer exceção do tipo que declara ou derivadas.Além disso, um único bloco try pode ter várias cláusulas catch. Nesse caso a ordem em que as cláusulas catch aparecem importa: as exceções mais genéricas devem ser tratadas após as mais específicas.

Irei mostrar como o Código abaixo funciona:

try{
 //Faz algo que pode fazer as exceções X,Y,Z
}
catch (X e){
 //lida com a exceção e de X
}
catch (Y e){
//lida com a exceção e de Y
}
catch (Z e){
//lida com a exceção e de Z
}
finally{
 //sempre vai rodar no fim
}

Então o seguinte código funciona assim:

A exceção para no exato ponto de origem da exceção, a máquina virtual procura pelo primeiro bloco catch que se encaixa com a exceção, se encontrar ele trata a exceção e vai para o finally ou ele vai direto para o finally.

É uma excelente idéia tratar exceção por exceção de vez de todas ao mesmo tempo, onde que se tratar todas ao mesmo tempo não tem como saber qual é a exceção exata que ocorreu o imprevisto.

Entendendo melhor o finally

O comando finally é utilizado para forçar a execução de um trecho de código, mesmo que não ocorra uma exceção, podendo ser executado com ou sem o bloco catch. O bloco de comandos é executado nas seguintes condições:

  • Fim normal do método
  • Instrução return ou break
  • Caso uma exceção tenha sido gerada

Exceções como Objetos

Erros e exceções em Java são Ojetos, possuindo atributos e métodos, onde cada exceção armazena um Strig que informa o tipo de erro ocorrido. Essa String pode ser obtida pelo método getMessage().

Exemplo:

//...
catch (ArrayIndexOutOfBoundsException e){
 System.out.println("Mensagem: " + e.getMessage());
}

Propagando Exceções

Pode-se delegar o tratamento de uma exceção para a porção de código do programa que chamou um método que gerou a exceção.

  • Se for uma exceção não verificada, não é preciso fazer nada, se a exceção não for capturada,ela será tratada no método anterior, e assim por diante
  • Se for uma exceção verificada, é preciso obrigatóriamente capturá-la ou utilizar a cláusula throws na definição do método, que delega a captura para o chamador.

Eis um caso de uma exceção verificada:

public void gravaList() throws IOException {
 PrintWriter arq = new PrintWriter(new FileWriter("texto.txt"));
 for(int i = 0 ; i < lista.size(); i++){
  arq.println(lista.get(i));
 }
}

Neste exemplo, sabe-se que o construtor de FileWriter pode gerar uma exceção IOException, que é verificada, ou seja, deve ser obrigatoriamente capturada ou propagada. Caso contrário, o compilador acusará erro de compilação, por isso é incluida a cláusula throws. Com isso, o tratamento da exceção deverá ser realizado pelo método que chama a gravaLista().

Gerando Exceções

Qualquer exceção pode ser gerada através do comando throw. É possível gerar uma exceção da API Java ou até criar uma exceção própria. Como exceções são Objetos,precisamos criar um novo objeto que é uma instância do tipo de exceção desejada

  • Uma aplicação disso é indicar a ocorrência de erros no construtor de uma classe: é a Única forma de informar que houve algum problema lá.
  • A API Java define alguns tipos de exceções mais genéricas, que podem ser utilizadas se for o caso:
    • IllegalArgumentException: indica um parâmetro inválido em um método
    • IllegalStateException: indica um estado inválido para executar uma operação
    • UnsupportedOperationException: indica que a operação não pode ser realizada pelo método

Vamos pegar como exemplo uma classe Circulo, onde no construtor ele recebe um raio, uma exceção nesse caso é o raio ser zero, o que não pode acontecer:

public class Circulo
{
 private double raio;

 public Circulo(double raio){
   if(raio <= 0){
     throw new IllegalArgumentException("Raio não pode ser menor ou igual a Zero!"); 
   }else{
      this.raio = raio;
    }
 }
//...
}