Unidade VI – Exceções e Interfaces

Apresentação em tema: "Unidade VI – Exceções e Interfaces"— Transcrição da apresentação:

1 Unidade VI – Exceções e Interfaces
Universidade Federal da Paraíba Centro de Ciências Exatas e da Natureza Departamento de Informática Unidade VI – Exceções e Interfaces Linguagem de Programação I Daniela Coelho Batista Guedes Pereira ©

2 Unidade VI Conteúdo abordado: Tratamento de Exceções Pacotes

3 Tratamento de Exceções
Exceção = É um evento que ocorre durante a execução de um programa que modifica o fluxo normal das instruções Erros tratados = software + robusto Tratamento de erros convencional: Código da aplicação + código para detectar o erro + código para tratar o erro Tratamento de erros de Java: Separação entre o código da aplicação dos outros dois através de uma estrutura sintática da linguagem

4 Tratamento de exceções
Vantagens obtidas com o tratamento: Separar o código da aplicação dos códigos de tratamento de erros; Propagação de erros através da pilha de chamadas de procedimentos Agrupar erros por categorias

5 Exemplo (em C) main(){ char buffer[30]; le_arq(buffer); }
int le_arq(char *b){ FILE fd; fd = fopen(“dados.dat”, “rb”); fread(b, 30, 1, fd); close(fd); return 1; Reflete aqui! Pode haver erro!

6 Exemplo (em C) Código com tratamento de erros: int le_arq(char *b){
FILE fd; if ((fd = fopen(fd, “dados.dat”))==NULL) return 0; if (fread(b, 30, 1, fd) != 30){ close(fd); } return 1; Código mais difícil de ler!

7 Exemplo (em C) main(){ int ok; char buffer[30];
if (! le_arq(buffer)) { printf(“Erro ao ler arquivo\n”); } ... Teste de sucesso

8 Tratamento de erros em Java
try-catch-finally Detecção e tratamento de exceções throw Lançamento de exceções throws Indicação dos tipos de exceções que podem ser lançadas por um método

9 Uso do throw e do throws Lançando e sinalizando uma exceção:
/** Empilha um objeto na pilha */ public void empilha(Object e) throws PilhaCheiaException{ if (pilhaCheia()) { throw new PilhaCheiaException(); } elementos[topo++] = e;

10 Classe PilhaCheiaException
import java.lang.Exception; public class PilhaCheiaException extends Exception{ public PilhaCheiaException() { super("Pilha cheia"); }

11 Uso do try-catch-finally
public class MinhaClasse{ public static void main(String[] args){ Pilha p; p = new Pilha(10); try{ for(int i=0; i < 30; i++) p.empilha(new Integer(i)); System.out.println(p.toString()); } catch (PilhaCheiaException pce) { System.err.println("Pilha cheia!"); }

12 Esperando uma exceção (try)
Marca um bloco onde podem acontecer exceções. Pode ser seguido por zero ou mais blocos catch, onde as exceções são tratadas. Após o try o bloco finally é executado (se existir) ou então o próximo comando na seqüência.

13 Lançando uma exceção (throw)
Comando throw: Especifica um objeto a ser lançado, este objeto deve ser instância de qualquer subclasse de Throwable. Após um throw, o controle sai do bloco try e vai para algum bloco catch. O ponto de lançamento da exceção pode estar distante do bloco try onde ela ocorreu, mesmo assim o controle é transferido para o catch correto.

14 Lançando uma exceção (throw)
Fluxo de controle: throw o3 o1 o3.m3() m1() o1.m1() m3() o2.m2() m2() main() o2 m3() m2() m1() main()

15 Tratando uma exceção (catch)
Um bloco catch deve declarar um parâmetro do tipo da exceção a ser tratada. Este parâmetro deve ser um objeto de alguma subclasse de Throwable. Pode haver mais de um bloco catch num bloco try. Não pode haver dois catchs para o mesmo tipo de exceção num try.

16 Tratando em m2() Método m3() de o3 : Método m2() de o2:
public void m3() throws OopsException{ if (algo deu errado) throw new OopsException(“Erro tal”); } Método m2() de o2: public void m2(){ try{ o3.m3(); } catch (OopsException e){...}

17 Tratando em m1() Método m3() de o3 : Método m1() de o1:
public void m2() throws OopsException{ ... o3.m3(); } Método m1() de o1: public void m1() { try { o2.m2(); } catch (OopsException e){...} m3() é o mesmo de antes

18 Cláusula throws E o método m2() de o2? Ele não lançou nenhuma exceção OopsException. Não lançou mas usou internamente um método, m3(), que lança esta exceção. Como m2() não quis tratar a exceção lançada por m3() ele teve que sinalizar que pode, indiretamente, lançar esta exceção. Sinalizar = pôr throws na assinatura.

19 Cláusula throws Método m2() de o2: Sintaxe de uso do throws:
public m2() throws OopsException { ... o3.m3(); } Sintaxe de uso do throws: método (pars) throws E1, E2, E3... m2 não tratou! Mas teve que sinalizar!

20 Trecho de Código em Java com Tratamento de Entrada de Dados – Usando Exceções
public static void main(String[] args) { ... int op = 0; boolean errado; for(;;){ errado = true; while(errado){ try{ op = Integer.parseInt(JOptionPane.showInputDialog("1 – Cad. Aluno Graduação" + "\n2 - Cad. Aluno Pós" + "\n3 – Adicionar Disciplina" + "\n4 - Trancar Período" + "\n5 – Calcular CRE" + "\n6 - Sair")); errado = false; } catch(NumberFormatException n){ JOptionPane.showMessageDialog(null, "Por favor, Digite um número válido!", "Error", JOptionPane.ERROR_MESSAGE); } } //fim do while } //fim do método main

21 Resumo Ao implementar um método, observe se os métodos dos objetos utilizados na implementação lançam alguma exceção. Você deve tratar a exceção (try) ou sinalizar que seu método também pode lançar esta exceção (throws). Se nenhum método tratar a exceção ela será tratada pela Java Virtual Machine ou pelo processamento de eventos da GUI.

22 Hierarquia de exceções
Exceções checadas Exceções não checadas

23 Hierarquia de exceções
Error (são problemas sérios de sistema que podem ocorrer em qualquer lugar, e a maioria dos programas não é capaz de se recuperar deles) LinkageError VirtualMachineError Exception IOException RuntimeException (exceções geradas pela JVM) ArithmeticException, NumberFormatException, NullPointerException, IllegalArgumentException, ArrayIndexOutOfBoundsException

24 Hierarquia de exceções
Java classifica as exceções em: Exceções Checadas (verificadas) As exceções checadas disparadas por um método precisam ser listadas na cláusula throws desse método. Se uma exceção não é listada, o compilador emite uma mensagem de erro, indicando que a exceção deve ser capturada (com o try/catch no corpo do método) ou declarada(com uma cláusula throws). São todas as exceções que não sejam RuntimeExceptions.

25 Hierarquia de exceções
Java classifica as exceções em: Exceções Não Checadas (não verificadas) RuntimeExceptions podem ser disparadas de quase todos os métodos, de modo que seria incômodo para os programadores serem obrigados a listá-las em todas as definições de métodos. Tais exceções não precisam ser listadas na cláusula throw de um método, mas comumente, são as exceções que são capturadas e tratadas em aplicativos Java.

26 Pacotes

27 Pacotes Coleção de classes e interfaces relacionadas com um espaço de proteção e de nomes comuns. Identificar classes com características comuns. Facilidade para encontrar classes desejadas. Nomes de classes num pacote não entram em conflito com nomes de classes de outros pacotes. Facilitar o acesso entre classes no mesmo pacote.

28 Criação de pacotes Comando package:
package estruturas; class Pilha { ... } Cada arquivo fonte de classe de um pacote deve conter um comando package indicando o nome do pacote.

29 Criação de pacotes Dentro de um arquivo deve existir apenas uma única classe com acesso public. Esta classe dá nome ao arquivo. Arquivos de classes sem o comando package são colocadas num pacote default. Convenção de nomes de pacotes utilizada na Internet: com.empresa.pacote

30 Usando pacotes Importados automaticamente pela JVM: default, java.lang, pacote atual Para usar uma classe pública de um pacote: Usar o nome qualificado da classe: x = new bib.estruturas.Pilha(); Importar a classe: import bib.estruturas.Pilha; Importar todo o pacote: import bib.estruturas.*;

31 Usando pacotes Importações Estáticas ( A partir de Java 5.0)
Uma declaração static import permite que o programador referencie um membro (método ou um atributo) estático (classe) importado sem precisar colocar o nome da classe na frente. Importar um membro de classe particular: import static nomedoPacote.NomedaClasse.nomedoMembrodeClasse; import static java.lang.Math.PI; Importar todos os membros de classe de uma classe: import static nomedoPacote.NomedaClasse.*; import static java.lang.Math.*;

32 Usando pacotes Importações Estáticas
import static java.lang.Math.*; public class StaticImportTest { public static void main( String args[] ){ System.out.printf( "sqrt( ) = %.1f\n", sqrt( ) ); System.out.printf( "ceil( -9.8 ) = %.1f\n", ceil( -9.8 ) ); System.out.printf( "log( E ) = %.1f\n", log( E ) ); System.out.printf( "cos( 0.0 ) = %.1f\n", cos( 0.0 ) ); } // end main } // end class StaticImportTest

33 Gerenciamento de arquivos
Cada arquivo fonte deve estar num diretório que reflita o nome do pacote. package estruturas; public class Pilha { ... } estruturas Pilha.java Fila.java package estruturas; public class Fila { ... } estruturas.Pilha estruturas\Pilha.java

34 Gerenciamento de arquivos
O diretório base do pacote pode estar em qualquer ponto do sistema de arquivos. Outro exemplo: package bib.estruturas; public class Pilha { ... } bib Pilha.java estruturas

35 Gerenciamento de arquivos
O mesmo acontece com os bytecodes: package estruturas; public class Pilha { ... } Compilador Java estruturas Pilha.class Fila.class package estruturas; public class Fila { ... }

36 Gerenciamento de arquivos
Sugestão para organização: projeto X src classes estruturas estruturas Pilha.class Pilha.java Fila.class Fila.java

37 Classpath O compilador e o interpretador devem estar informados onde encontrar os arquivos fontes e de classes. Definindo um CLASSPATH: Conjunto de diretórios que contêm pacotes onde o compilador e o interpretador devem procurar por arquivos fontes e classes

38 Classpath Apenas diretórios que contêm diretório topo de pacotes devem ser listados. Exemplo: c:\projetoX\classes deve estar no classpath c:\projetoX\classes\estruturas não! Definindo um classpath: Variável CLASSPATH=c:\projetoX\src;... Diretiva -classpath ou –cp do compilador/interpretador: javac –cp c:\projetoX\src