PROGRAMAÇÃO ORIENTADA A OBJETOS -TRATAMENTO DE EXCEÇÕES Prof. Angelo Augusto Frozza, M.Sc. frozza@ifc-camboriu.edu.br
ROTEIRO 4. Sistemas de Tratamento de Exceções Exceções genéricas Classes de exceções
INTRODUÇÃO Exceções (Exceptions) São situações excepcionais e geralmente indesejáveis que podem ocorrer durante a execução de um programa; Podem ser tratadas incluindo-se código adequado no programa não são erros fatais; Mais precisamente, uma exceção é um evento que ocorre durante a execução de um programa que o interrompe o fluxo normal das instruções; Uma exceção altera o fluxo normal da execução de um programa;
INTRODUÇÃO Exemplos típicos de exceções: Índice de uma lista (Array) fora do limite permitido; Problemas em operações aritméticas overflows e divisão por zero; Argumentos inválidos na chamada de um método; Falta de memória; Acesso negado a um arquivo; Acesso a rede; Outros...
INTRODUÇÃO Exceções Por que tomar cuidado? Basicamente porque exceções não tratadas provocam a finalização do programa; Vantagens: Vantagem 1: Separa o código de manuseio do erro das outras linhas de código; Vantagem 2: Reporta os erros entre os métodos chamados; Vantagem 3: Agrupa os erros por tipos e diferencia entre erros possíveis;
INTRODUÇÃO Vantagem 1: Separação do código de manuseio de erro das outras linhas de código Programação tradicional código confuso; Programação Java código mais organizado, elegante e compacto, portanto mais legível;
INTRODUÇÃO Vantagem 1: Exemplos de fragmentos de código: ProgramaSemExcecao.java ProgramacaoComExcecao.java AcessoArquivo.java AcessoArquivoSemExcecao.java AcessoArquivoComExcecao.java
INTRODUÇÃO Vantagem 2: Reportar os erros ocorridos aos outros métodos chamados Capacidade de reportar o erro ocorrido entre os métodos executados anteriormente até o momento do erro Exemplo: ReportarErros.java
INTRODUÇÃO Vantagem 3: agrupar os erros por tipos e diferenciação entre erros Separar erros por categorias ou grupos Exceptions devem ser instâncias da classe Throwable ou subclasse de Throwable.
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Exceções Quando uma exceção ocorre, diz-se que uma exceção será lançada; O código que é responsável por fazer algo com a exceção é chamado de manipulador de exceções, em outras palavras, ele captura a exceção lançada;
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavras reservadas try e catch: try É usada para indicar um bloco de código no qual possam ocorrer exceções; Este bloco de código é chamado de região protegida, ou seja, código de risco; catch Cláusula associada a uma exceção específica ou mais abrangente, que permite manipular a exceção a partir de um bloco de código;
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavras reservadas try e catch: // programa sem o tratamento de exceção
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: Usado para inserir códigos de limpeza Os manipuladores de exceção (catch) são locais inapropriados para a limpeza depois da execução do código try, pois cada manipulador precisará de sua própria cópia do código de limpeza; Exemplo: Ao alocar um socket de rede ou abrir um arquivo em algum local da região protegida, cada manipulador de exceção teria que fechar o arquivo ou liberar o socket; Estes códigos podem ser inseridos em um bloco finally;
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: Fechará o código de execução tanto para try quanto para catch; Sempre será executado, se uma exceção for lançada ou não; Mesmo havendo uma instrução de return no bloco try, o bloco finally será executado logo após essa instrução; Então, é o local certo para fechar arquivos, liberar sockets de rede e executar qualquer outra limpeza que o código necessitar;
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: Sintaxe geral: try { A palavra try marca o início do tratamento de exceções; bloco_de_instrucoes } catch (instância de uma subclasse de Exception) { try deve ser seguido de um ou bloco_de_instrucoes mais catch ou exatamente um finally; } finally { O bloco finally é executado sempre, ocorrendo ou não uma bloco_de_instrucoes exceção; }
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: A cláusula finally não é obrigatória; É possível escrever um código try sem a cláusula catch, mas nesse caso, é obrigatório a implementação do finally: try { //instruções } finally { //faz a limpeza }
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: Exemplo de um código inválido: try { //instruções } System.out.println( exemplo de código inválido );
CAPTURAR EXCEÇÃO COM TRY, CATCH E FINALLY Palavra reservada finally: Outro código inválido: try { //instruções } System.out.println( exemplo de código inválido ); catch (Exception ex) { //tratamento da exceção }
PROPAGAÇÃO DE EXCEÇÕES NÃO CAPTURADAS Quando um método não fornece uma cláusula catch para uma exceção específica, então este método deve repassar a exceção (a responsabilidade); O que acontece a uma exceção transferida? É necessário entender o conceito de pilha de chamadas;
PROPAGAÇÃO DE EXCEÇÕES NÃO CAPTURADAS 1. A pilha de chamadas enquanto o método3() está sendo executado: 4 metodo3() metodo2() chama metodo3() 3 metodo2() metodo1() chama metodo2() 2 metodo1() main() chama metodo1() 1 main() main() inicia Ordem na qual os métodos são colocados na pilha. 2. A pilha de chamadas após o método3() ser finalizado. A execução volta para o método2(): 3 metodo2() metodo2() vai finalizar 2 metodo1() metodo1() vai finalizar 1 main() main() vai finalizar e a JVM terminará a sua execução Ordem na qual os métodos finalizam.
PROPAGAÇÃO DE EXCEÇÕES NÃO CAPTURADAS Exemplo:
PROPAGAÇÃO DE EXCEÇÕES NÃO CAPTURADAS Exemplo: lançando e capturando a exceção propagada. Se a string for vazia, uma exceção deverá ser lançada e capturada na chamada do método inverter().
LANÇANDO EXCEÇÕES Métodos podem lançar exceções para indicar condições de erro: public void metodo1() throws IOException {... throw new IOException( causa... ); } // ou public void metodo1() throws IOException, OutraExcecao {... }
LANÇANDO EXCEÇÕES Os métodos que os utilizam devem tratar as possíveis exceções: public void metodo2() { try { metodo1(); } catch (IOException e) { //fazer o tratamento } }
LANÇANDO EXCEÇÕES throw e throws Se um método não captura (catch) a exception, devese ao menos declará-la; A declaração faz-se através da palavra-chave throws; Declarar significa repassar esta exception para o método chamador;
LANÇANDO EXCEÇÕES throw e throws throw gera uma exception; Exige um objeto throwable como argumento throw e throws throw lança a exceção throws declara a exceção
LANÇANDO EXCEÇÕES Exemplo: Exceção tratada
HIERARQUIA DE EXCEÇÕES Quando uma exceção é lançada, o objeto de um subtipo Exception específico é lançado e inserido no manipulador de exceções como um argumento para a cláusula catch; Por isso, esse formato da cláusula catch: try { //instruções } catch (ArrayIndexOutOfBoundsException ex) { ex.printstacktrace(); } Neste exemplo, ex é a instância de uma classe chamada de ArrayIndexOutOfBoundsException; Assim, como qualquer outro objeto, podemos chamar seus métodos;
HIERARQUIA DE EXCEÇÕES Todas as classe de exceções são subtipos da classe Exception; Esta classe é derivada de Throwable Esta deriva de Object De Throwable derivam: Exception e Error Error: as classes que derivam desta representam situações incomuns que são causadas por erros no programa. Exemplo: falta de memória; Embora considerados como condições excepcionais, Error tecnicamente não são exceções porque não derivam da classe Exception; Faz pouco sentido tratá-los, pois a JVM já deve ter feito de tudo para contornar a situação;
HIERARQUIA DE EXCEÇÕES Hierarquia de classes As exceções RuntimeException, Error e todos os seus subtipos são exceções não verificadas, isto é, não precisam ser capturadas ou manipuladas.
HIERARQUIA DE EXCEÇÕES Tipos que podem ser lançados através de throws e que podem ser capturados: Exception Error RuntimeException Throwable Os subtipos de Exception são comumente capturados e tratados, já os demais raramente se faz.
HIERARQUIA DE EXCEÇÕES Manipulando uma hierarquia de classes Mais de um tipo de exceção pode ser capturada em uma única cláusula catch vale a herança Exemplo: try { //instruções } catch (IndexOutOfBoundsException e) { e.printstacktrace(); } Se algum código do bloco try lançar ArrayIndexOutOfBoudsException ou StringIndexOutOfBoundsException, a exceção será capturada e manipulada.
HIERARQUIA DE EXCEÇÕES Manipulando uma hierarquia de classes Este tipo de declaração pode acontecer, mas deve ser usado moderadamente; Especificando o tipo da superclasse, pode-se estar descartando informações valiosas sobre a exceção; Por exemplo: try { //... } catch (Exception e) { } //... Tratar um Exception é muito abrangente. Fica difícil identificar a real exceção.
HIERARQUIA DE EXCEÇÕES Correspondência de Exceções Situação: superclasse com vários subtipos A JVM tenta encontrar uma cláusula catch para o tipo da exceção que foi lançada Procura de cima para baixo (do primeiro catch ao último); Caso não seja encontrado, um manipulador para um supertipo da exceção será procurado; Se ainda assim não encontrar uma cláusula catch apropriada, então a exceção será propagada para baixo na pilha de chamadas Este processo é chamado de Correspondência de exceções ;
HIERARQUIA DE EXCEÇÕES Exemplo:
HIERARQUIA DE EXCEÇÕES Exemplo: Neste caso a exceção lançada foi FileNotFoundException. Mas poderia ser também um EOFException ou outra. Sendo estas subclasses de IOException, teremos a garantia que a exceção será tratada caso não for FileNotFoundException. Como qualquer outra exceção que estende IOException pode ser lançada, isso nos obriga a declará-la. Veja exemplo do próximo slide.
HIERARQUIA DE EXCEÇÕES Exemplo: Outras exceções de IOException, diferentes de FileNotFoudException, podem ocorrer. Isso nos obriga tratá-las...
HIERARQUIA DE EXCEÇÕES Exemplo: é necessário cuidar a ordem da declaração Como FileNotFoundException é um subtipo de IOException, esta não pode vir depois.
DECLARAÇÃO DE EXCEÇÕES Como saber se um método lança uma exceção? Identificar a interface pública do método void metodo(int x) throws Excecao1, Excecao2;
DECLARAÇÃO DE EXCEÇÕES Todo método deve tratar todas as exceções verificadas fornecendo uma cláusula catch, ou então listar cada exceção verificada que não tiver recebido tratamento como uma exceção lançada Regra conhecida como tratar ou declarar;
DECLARAÇÃO DE EXCEÇÕES Exemplo: Como tem um throw, o método deverá declarar um throws avisando que uma exceção pode ser Lançada. Isto só não é necessário para exceções que estendem RuntimeException.
DECLARAÇÃO DE EXCEÇÕES Exemplo: corrigindo o problema... Agora é necessário tratar a exceção ou reportá-la.
DECLARAÇÃO DE EXCEÇÕES Exemplo: corrigindo o problema... REPORTANDO... Reportando até o main(). Faz pouco sentido...
DECLARAÇÃO DE EXCEÇÕES Exemplo: corrigindo o problema... TRATANDO...
DECLARAÇÃO DE EXCEÇÕES Exceções verificadas e não verificadas Verificada: Terá que ser capturada em algum local do código; Se um método que lance uma exceção verificada for chamado, mas não capturar a exceção em algum local, o código não será compilado; Por isso são chamadas de verificadas o compilador verifica para se certificar se elas foram declaradas ou manipuladas.
DECLARAÇÃO DE EXCEÇÕES Exceções verificadas e não verificadas Não-verificada: Exceções de tempo de execução são consideradas como não-verificadas; Todas as exceções que não são derivadas de java.lang.runtimeexception são verificadas.
HIERARQUIA DE EXCEÇÕES Hierarquia de classes
CRIANDO CLASSES DE EXCEÇÃO Para criar uma classe de Exceção própria, basta criar uma subclasse de Exception; Ou também criar uma subclasse a partir de subclasses de Exception;
CRIANDO CLASSES DE EXCEÇÃO Ao chamar um método com uma exceção declarada, a mesma deverá tratada ou reportada. Se a exceção foi lançada, deverá ser também declarada.
CRIANDO CLASSES DE EXCEÇÃO Exemplo: otimizando a classe de exceção Sobrecarregando os construtores de MinhaExcecao, é possível simplesmente definir uma mensagem, uma causa ou ambas.
CRIANDO CLASSES DE EXTENSÃO Exemplo: usando a classe de exceção otimizada
RESUMO Introdução e conceitos Capturando exceção usando try, catch e Finally Propagando exceções não capturadas Lançando exceções Hierarquia de exceções Correspondência de exceções Declaração de exceções Criação de classes de exceção