Curso Java - Básico - Aula 8

Tratamento de Erros (1)

  • Exceções em Java
    • Nem todos os erros são detectados em tempo de compilação.
    • Linguagens procedurais tratam erros através de convenções como valores de retorno e flags.
    • Em linguagens OO esse tratamento está estruturalmente embutido.
    • A formalização do tratamento de exceções garante um código de mais fácil leitura.

Tratamento de Erros (2)

  • Vantagens:
    • O tratamento do erro pode ser delegado a contextos mais altos onde decisões mais apropriadas podem ser tomadas.
    • Um mesmo erro não precisa ser checado em diferentes pontos do programa.

Argumentos da Exceção

  • A criação da exceção
    • Exceções são objetos de primeira classe - classe Exception.
    • Como qualquer objeto em Java, a exceção é criada com um new, que aloca o espaço necessário à instância e chama seu construtor.
    • Há dois tipos de construtores:
      • O padrão, sem argumentos

        Exception()

      • Outro com uma string como argumento para relatar alguma informação relevante.

        Exception(String message)

      • Exemplo:
        • if(object == null) throw new NullPointerException();

Tratamento de Erros (3)

  • Problemas normais X Condições excepcionais
    • Em um problema normal, as informações disponíveis no contexto atual são suficientes para lidar com a dificuldade.
    • Em uma condição excepcional, o processamento não pode continuar pois as informações disponíveis no contexto atual nao são suficientes para tratar o problema.
    • Quando uma condição excepcional ocorre, gera-se uma exceção a fim de delegar o problema a um contexto de mais alto nível.

Exceções Básicas

  • O Funcionamento de Exceção
    • Quando uma exceção é gerada.
    • A execução é interrompida.
    • Um objeto exceção é criado.
    • Uma referência a ele é ejetada para fora do contexto atual.
    • O mecanismo de tratamento de exceções começa a procurar o ponto apropriado para continuar a execução do programa.
    • Este ponto é chamado "exception handler".
    • Nele o problema é tratado de forma que o programa busque um outro caminho ou simplesmente pare.
    • Pode-se ativar procedimentos em cascata relançando-se a exceção para o escopo acima do atual, após o tratamento do problema dentro desse escopo.

Argumentos da Exceção (2)

  • A premissa throw
    • Uma referência ao objeto exceção é dada ao throw, que faz com que esse objeto seja retornado pelo método mesmo que o tipo do objeto não seja o esperado.
    • O objeto exceção é retornado ao ponto do programa onde exceções são tratadas ao invés do ponto onde o método foi chamado.
    • O throw pode retornar qualquer objeto cuja classe herde direta ou indiretamente da classe Throwable.
    • Isso permite que diferentes exceções sejam geradas para diferentes tipos de erros.

Região Guardada da Exceção

  • O bloco try
    • Se um método gera uma exceção, assume-se que ela será capturada e tratada em algum ponto do programa.
    • Para impedir que a execução de um método seja interrompida quando uma exceção é gerada, usa-se a premissa try.
    • O try define um escopo dentro do qual o método pode capturar uma exceção:

      ./images/excecao.jpg

Capturando a Exceção (1)

  • A Premissa catch
    • As exceções geradas são capturadas pelos tratadores de exceção, podendo existir um para cada tipo de exceção que se deseja capturar.

      ./images/captura.jpg

Capturando a Exceção (2)

  • O mecanismo de tratamento de exceções termina assim que a primeira cláusula catch com tipo correspondente de argumento é executada.

    ./images/captura_excecao.gif

Terminação X Recuperação (1)

  • Modelos básicos em tratamento de exceções:
    • Terminação: quando o erro é tão crítico que não é possível retornar para onde a exceção ocorreu.
    • Recuperação: onde espera-se que a situação seja retificada para que o método seja reinvocado, obtendo sucesso em sua execução.

Terminação X Recuperação (2)

  • Em Java o tratamento é somente de terminação, uma vez que não é possível retornar ao ponto de onde a exceção foi lançada.

A Especificação da Exceção

  • A premissa throws
    • Java força uma sintaxe que informa ao programador cliente quais são as possíveis exceções que um método pode gerar.
    • As possíveis exceções são listadas na declaração do método utilizando-se a premissa throws:
      • void myMethod()throws tooBig,tooSmall, DivZero{//...
    • O compilador exige que qualquer possível exceção seja tratada ou declarada pelo chamador de um método em que a premissa throws foi utilizada .

Tratando Qualquer Exceção (1)

  • O tipo Exception
    • É possível capturar qualquer tipo de exceção utilizando-se a classe base das exceções como parâmetro da cláusula catch:

      ./images/tratandoqqexcecao.jpg

Tratando Qualquer Exceção (2)

  • Obtendo Informações
    • Como a classe Exception é a base de todas as exceções, para se obter maiores informações a respeito do exceção gerada, pode-se utilizar os métodos declarados pelo tipo básico Throwable:
  • getMessage() - Retorna mensagem passada pelo construtor
  • toString() - Retorna nome da excecao e mensagem
  • printStackTrace() - imprime detalhes sobre exceção

Relançando a exceção

  • Atualizando as informações:
    • Há casos em que se deseja relançar uma exceção que acabou de ser capturada.
    • Exceções relançadas são tratadas pelo contexto acima do atual, ignorando outras cláusulas catch pertencentes ao mesmo bloco try.
    • Se a exceção é simplesmente relançada, a informação sobre esta exceção ainda é a original.
    • No entanto as informações podem ser atualizadas utilizando-se o método fillInTrackTrace(), que retira o escopo atual da stack.

      ./images/relancar_excecao.gif

Exceções Padrão em Java (1)

  • Tipos de objetos Throwable
    • A classe Throwable descreve qualquer objeto que pode ser lançado como uma exceção e pode ser subdividida em dois tipos:
    • Error : representa erros de sistema e de compilação que não se tem interesse em capturar.

Exceções Padrão em Java (2)

  • Exception : é a classe básica que pode ser lançada:
  • Manualmente, de qualquer método de qualquer classe Java.
  • Automáticamente devido a erros ocorridos em tempo de execução.
    • Todas as exceções descendem de java.lang.Exception

Exceções Padrão em Java (3)

  • Exceções checadas automaticamente:
    • Exceções descendentes da classe RuntimeException não precisam ser incluídas nas especificações das exceções, pois são checadas e capturadas automaticamente.
    • RuntimeExceptions que não são tratadas, voltam todo o caminho até o método main().
    • RuntimeExceptions representam erros de programação.

Exceções Padrão em Java (4)

  • Especializando uma exceção:
    • Uma exceção pode ser criada para tratar erros especiais que não foram previstos quando a hierarquia de exceções foi criada.
    • Novas exceções devem descender da classe Exception.

Restrições da Exceção

  • Redefinindo métodos
    • Ao se redefinir um método, as únicas exceção que podem ser declaradas são as que foram especificadas na classe base.
    • Exceções podem ser adicionadas ao construtor das classes derivadas, mas devem também tratar as exceções do construtor da classe base.
    • As exceções dos métodos normais tem que ser iguais ou herdar das exceções especificadas na classe base.
    • Pode-se escolher não declarar nenhuma exceção, mesmo que existam exceções especificadas na classe base.

O Uso do finally

  • Garantindo a execução de um código
    • A cláusula finally é utilizada para garantir a execução de um código caso tenha ou não ocorrido uma exceção no bloco do try.

      ./images/finally.gif

Finalizando a Exceção

  • Recuperando valores iniciais:
    • Em linguagens sem garbage collection ou chamada automática de destrutores, o finally pode ser usado para liberar a memória correspondente ao bloco try onde ocorreu uma exceção.
    • O finally, em Java, é utilizado quando há a necessidade de liberar recursos externos ao sistemas.

Falhas na Exceção (1)

  • O caso em que exceções podem ser simplesmente perdidas:
    • Uma exceção é gerada dentro da cláusula finally oculta qualquer exceção ocorrida anteriormente.

      ./images/falhas.jpg

Falhas na Exceção (2)

  • Saída do código anterior:

    ./images/falhas2.jpg

  • Observe que ExceçãoImportante ocorreu e foi perdida, isto é, não reportada.

Construtores e a Exceção

  • Tratando exceções ocorridas dentro do construtor
    • Algumas ações devem ser desfeitas caso ocorra uma exceção.
    • Se a exceção ocorre dentro do construtor, algumas ações podem não ser desfeitas devidamente.
    • Cuidados adicionais devem ser tomados pois o usuário da classe considera que o construtor irá inicializar uma instância de modo apropriado.
    • Um erro não contornável em um construtor deve ser propagado para que o cliente possa percebê-lo.

Casamento de Exceção (1)

  • Procurando a exceção correspondente
    • Qualquer exceção gerada é sempre tratada pela cláusula catch mais próxima cujo o tipo é o mesmo ou herda da exceção ocorrida:

O guia da Exceções

  • O uso das exceções permite:
    • Consertar um problema e chamar o método novamente.
    • Fazer modificações e continuar sem reinvocar o método.
    • Retornar um valor alternativo ao invés do esperado.
    • Fazer o possível no contexto atual e lançar uma exceção diferente, para um contexto mais alto.
    • Terminar o programa.
    • Simplifique. Se o código se tornar muito complicado com o esquema de tratamento de exceções, esse se tornará penoso e chato de se usar.
Û ƒ