Java 13 Excecoes

Exceções Regis Pires Magalhães [email_address]

Problema 1 Como evitar que uma data inválida seja armazenada no atributo data?

Soluções Desconsiderar a operação caso uma data inválida seja identificada Ficamos na incerteza do sucesso ou não da operação. Mostrar uma mensagem de erro A classe fica atrelada à interface com o usuário. Retornar um código de erro Os clientes precisam fazer testes exatamente após a chamada do método. Além disso, para cada chamada, um novo teste precisa ser realizado. Retornar um valor especial de erro quando o método já retorna algum valor significativo é deselegante e pode confundir quem está usando o método.

Problema 2 // ... Conta minhaConta = new Conta(); minhaConta.deposita(100); minhaConta.setLimite(100); minhaConta.saca(1000); // o saldo é -900? É 100? É 0? // A chamada ao método saca funcionou?

Soluções public boolean saca( double quantidade) { if (quantidade > this .saldo + this .limite) { System.out.println( "Saque fora do limite!" ); return false ; } else { this .saldo = this .saldo – quantidade; return true ; } } Mostrar mensagem de erro Retornar código de erro

Problema 2 Como sinalizar quando o usuário passou um valor negativo? Uma solução é alterar o retorno de boolean para int, e retornar o código do erro que ocorreu. Isto é considerado uma má prática (uso de “magic numbers”). Desvantagens: Perde-se o retorno do método; O valor retornado é “mágico” (só legível perante extensa documentação) Não obriga o programador a tratar esse retorno, e no caso de esquecer isso seu programa continuará rodando.

Exceções Uma exceção representa uma situação que normalmente não ocorre e representa algo de estranho ou errado no sistema. Indicam algum tipo de condição excepcional (como um erro) ocorrido ao programa. Exemplos de situações que geram exceções: Índice de array fora dos limites Overflow numérico Divisão por zero Estouro de memória

Por que usar exceções? Separam a parte de lógica do sistema da parte de tratamento de erros. Evitam a criação de um código específico para cada situação em que um tipo de erro ocorre. Concentram o tratamento de erros em partes específicas do código, facilitando sua legibilidade e manutenção.

Exceções Uma exceção lançada interrompe o fluxo normal do programa. Se o método onde ela ocorrer não a capturar, ela será propagada para o método que chamar esse método e assim por diante. Se ninguém capturar a exceção, ela irá causar o término da aplicação. Se em algum lugar ela for capturada, o controle pode ser recuperado.

Pilha de Execução public class TesteErro { public static void main(String[] args) { System. out .println( "inicio do main" ); metodo1 (); System. out .println( "fim do main" ); } public static void metodo1() { System. out .println( "inicio do metodo1" ); metodo2 (); System. out .println( "fim do metodo1" ); } public static void metodo2() { System. out .println( "inicio do metodo2" ); int [] array = new int [10]; for ( int i = 0; i <= 15; i++) { array[i] = i; System. out .println(i); } System. out .println( "fim do metodo2" ); } }

Rastro da Pilha - Stacktrace Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException : 10 at TesteErro.metodo2( TesteErro.java:18 ) at TesteErro.metodo1( TesteErro.java:10 ) at TesteErro.main( TesteErro.java:4 )

Soluções try { for ( int i = 0; i <= 15; i++) { array[i] = i; System.out.println(i); } } catch (ArrayIndexOutOfBoundsException e) { System.out.println( "erro: " + e); } for ( int i = 0; i <= 15; i++) { try { array[i] = i; System.out.println(i); } catch (ArrayIndexOutOfBoundsException e) { System.out.println( "erro: " + e); } }

Bloco try O bloco try "tenta" executar um bloco de código que pode causar exceção. Deve ser seguido por: Um ou mais blocos catch(TipoDeExcecao ref) . E/ou um bloco finally . O bloco try não pode aparecer sozinho, devendo ser seguido por pelo menos um catch ou por um finally .

Bloco catch Blocos catch recebem um tipo de exceção como argumento Se ocorrer uma exceção no try , ela irá descer pelos catch até encontrar um que declare capturar exceções de uma classe ou superclasse da exceção. Apenas um dos blocos catch é executado.

Bloco finally O bloco finally contém instruções que devem ser executadas independentemente da ocorrência ou não de exceções. Exemplos disso são códigos de “limpeza” como fechamento de arquivos, liberação de recursos, etc.

Exceções não checadas public class Exemplo09 { public static void main(String args[]) { int i = 5571; i = i / 0; System. out .println( "O resultado " + i); } } Exception in thread "main" java.lang.ArithmeticException : / by zero at Exemplo09.main( Exemplo09.java:4 )

Exceções não checadas public class Exemplo09 { public static void main(String args[]) { Conta c = null ; System. out .println( "Saldo: " + c.getSaldo()); } } Exception in thread "main" java.lang.NullPointerException at Exemplo09.main( Exemplo09.java:4 )

Exceções não checadas public class Exemplo09 { public static void main(String args[]) { int i = Integer. parseInt ( "a" ); System. out .println(i); } } Exception in thread "main" java.lang.NumberFormatException : For input string: "a" at java.lang.NumberFormatException.forInputString( NumberFormatException.java:48 ) at java.lang.Integer.parseInt( Integer.java:447 ) at java.lang.Integer.parseInt( Integer.java:497 ) at Exemplo09.main( Exemplo09.java:3 )

Exceções não checadas Usadas em erros que poderiam ser evitados pelo programador. Não é obrigatório usar o try/catch nessas exceptions. São chamadas de não checadas (unchecked), pois o compilador não checa se elas estão sendo tratadas.

Exceções checadas import java.io.FileReader; public class Exemplo09 { public static void main(String args[]) { FileReader f = new FileReader( "teste.txt" ); } } Exception in thread "main" java.lang.Error: Unresolved compilation problem: Unhandled exception type FileNotFoundException at Exemplo09.main( Exemplo09.java:5 )

Tratamento de Exceções - catch import java.io.FileNotFoundException; import java.io.FileReader; public class Exemplo09 { public static void main(String args[]) { try { FileReader f = new FileReader( "teste.txt" ); } catch (FileNotFoundException e) { System. out .println( "Arquivo não existe" ); } } }

Propagação de Exceções - throws import java.io.FileNotFoundException; import java.io.FileReader; public class Exemplo09 { public static void main(String args[]) throws FileNotFoundException { FileReader f = new FileReader( "teste.txt" ); } }

Tratamento de Exceções E se uma letra for digitada? O que acontece?

Lançamento de Exceções public class Conta { double saldo ; // ... public boolean saca( double valor){ if ( this . saldo < valor){ return false ; } else { this . saldo -=valor; return true ; } } // ... }

Lançamento de Exceções public class Conta { double saldo ; // ... public void saca( double valor){ if ( this . saldo < valor){ throw new IllegalArgumentException( "Saldo insuficiente" ); } else { this . saldo -=valor; } } // ... }

IllegalArgumentException Diz que um parâmetro enviado ao método é inválido. É uma Exception unchecked pois estende RuntimeException. Já faz parte do Java. Para capturar essa exceção: // ... Conta cc = new ContaCorrente(); cc.deposita(100); try { cc .saca(100); } catch (IllegalArgumentException e){ System.out.println(e.getMessage()); } // ...

Criando Exceções public class SaldoInsuficienteException extends RuntimeException { public SaldoInsuficienteException(String message) { super (message); } }

Usando nossas exceções public class Conta { double saldo ; // ... public void saca( double valor){ if ( this . saldo < valor){ throw new SaldoInsuficienteException( "Use um valor menor" ); } else { this . saldo -=valor; } } // ... } // ... Conta cc = new ContaCorrente(); cc.deposita(100); try { cc .saca(100); } catch (SaldoInsuficienteException e){ System.out.println(e.getMessage()); } // ...

Tratamento de Exceções Não tratar exceções e simplesmente lançá-las em todos os métodos evita trabalho, mas torna o código menos robusto. Mas o pior é capturar exceções e nada fazer, permitindo que erros graves passem despercebidos e causem problemas dificílimos de localizar no futuro. NUNCA escreva o seguinte código:

Lançamento de Exceções Uma exceção precisa ser criada com new e depois lançada com throw . Uma declaração throws (observe o "s") é obrigatória em métodos e construtores que deixam de capturar uma ou mais exceções checadas que ocorrem em seu interior. throws declara que o método pode provocar exceções do tipo declarado (ou de qualquer subtipo). A declaração abaixo declara que o método pode provocar qualquer exceção (nunca faça isto). public void m() throws Exception {...} Métodos sobrescritos não podem provocar mais exceções que os métodos originais.

Hierarquia de Exceções Toda exceção em Java é um objeto que é uma instância de alguma subclasse da classe java.lang.Throwable . java.lang.Throwable possui duas subclasses de exceções (erros e exceções) padronizadas: java.lang.Error Normalmente indicam problemas durante o carregamento de classes, falta de memória para JVM, etc. Exceções desse tipo devem ser consideradas irrecuperáveis e não devem ser tratadas . Exemplos: java.lang.OutOfMemoryError java.lang.InternalError java.lang.Exception Normalmente indicam problemas que são passíveis de recuperação sem que o programa seja terminado. Devem ser tratadas . Exemplos: java.io.EOFException java.lang.ArrayAccessOutOfBounds

Hierarquia de Exceções Construtores de Throwable Throwable() Throwable(String message) Throwable(String message, Throwable cause) Throwable(Throwable cause) Alguns métodos de Throwable String getMessage() Retorna mensagem passada pelo construtor Throwable getCause() Retorna exceção que causou esta exceção [Java 1.4] String toString() Retorna nome da exceção e mensagem void printStackTrace() Imprime detalhes (stack trace) sobre exceção

Hierarquia de Exceções RuntimeException e Error Exceções não verificadas (unchecked) em tempo de compilação Subclasses de Error não devem ser capturadas (são situações graves em que a recuperação é impossível ou indesejável). Subclasses de RuntimeException representam erros de lógica de programação que devem ser corrigidos ( podem ser capturadas). Exception Exceções verificadas (checked) em tempo de compilação (exceção à regra são as subclasses de RuntimeException). Compilador exige que sejam ou capturadas ou declaradas pelo método que potencialmente as provoca.

Hierarquia de Exceções Se, entre os blocos catch , houver exceções da mesma hierarquia de classes, as classes mais específicas (que estão mais abaixo na hierarquia) devem aparecer primeiro. Se uma classe genérica aparecer antes de uma mais específica, uma exceção do tipo da específica jamais será capturado. O compilador detecta a situação acima e não compila o código.

Criando uma Exceção A classe java.lang.Throwable é a raiz da hierarquia de classes de exceção e de erros. java.lang.Throwable define um método denominado getMessage() que retorna uma mensagem descritiva do problema ocorrido. Para definir um novo tipo de exceção crie uma classe que estenda a classe java.lang.Throwable ou alguma de suas subclasses. Normalmente estende-se Exception ou RuntimeException . Defina atributos e métodos específicos da exceção. Para armazenar uma mensagem descritiva da exceção, defina um construtor da exceção que recebe uma String e invoca (direta ou indiretamente) o construtor correspondente da superclasse java.lang.Throwable .

Exceções verificadas (checked) ou não verificadas (unchecked)? Use exceções não verificadas para erros irrecuperáveis ; e verificadas para código que pode ser devidamente tratado . Exceções não verificadas levam a: Menos código. Código mais legível – não é preciso capturar exceções que não serão tratadas. Aumento de produtividade. Se algo terrível aconteceu como um método de negócio não conseguir se conectar com o banco, use não verificada. Essa é a opinião de alguns autores, que defendem que o máximo que se pode fazer nesse caso é informar o usuário, pois não há como remediar a situação. A desvantagem disso é que pode-se esquecer de tratar tal problema.

Exceções verificadas (checked) ou não verificadas (unchecked)? A inclusão de uma exceção verificada a uma interface pode levar a muitas alterações no código. Exceções verificadas são bem melhores que códigos de retorno de erro. Não há perigo de esquecer de tratá-las. Se uma exceção sempre deve é tratada é preferível que seja verificada (Ex.: timeout de um processamento).

Resumo Tratar: try { ... } catch (TipoExcecao ex) { ... } finally { ... } Lançar: if (condicao) throw new MinhaExcecao("Você só pode ser uma anta " ); Progagar / Deixar passar: public int buscaLojas() throws MinhaExcecao() { ... } Criar / definir: public class MinhaExcecao extends Throwable { ... }

Prática Implemente as exceções abaixo. Lance-as em PessoaArrayBD, PessoaVectorBD. Trate-as em AppMain.

Java 13 Excecoes

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Java 13 Excecoes (20)

Mais de Regis Magalhães (20)

Java 13 Excecoes