Exceções para certificação Java

1. Curso Preparatório para
Certificação Java
Prof.º Eduardo Mendes

2. Certificação Java
Prof.º Eduardo Mendes

3. Agenda
 A certificação de programador Java
 Revisão
 Declarações e Controle de Acesso
 Orientação a Objetos
 Atribuições
 Operadores
 Controle de Fluxo, Exceções e Assertivas
 String, E/S (I/O), Formatação e Parsing
 Genéricos e Conjuntos
 Classes Internas
 Threads
 Desenvolvimento

4. Controle de Fluxo
Exceções
e Assertivas

5. Manipulando
exceções

6. Objetivos para a certificação
2.4 Escrever códigos que façam uso apropriado
de exceções e de cláusulas
de manipulação de exceções (try, catch, finally)
e declarar método, subscritos ou não,
os quais lancem exceções
2.5 Reconhecer o efeito de uma exceção lançada em um
ponto específico do fragmento de um código.
É bom ressaltar que a exceção pode ser de tempo de
execução, verificada ou um erro.

7. Manipulação de exceções
Podem garantir a
robustez de uma
aplicação
Permite detectar
erros de maneira
mais fácil
Separa nitidamente o
código que manipula a
exceção do código
que gera a exceção
Permite lidar com
diferentes possíveis
exceções
Permite realizar
operações que devam
ser realizadas
independentemente
do erro

9. Terminologia
 Exceção
 condição excepcional
 ocorrência que altera o fluxo normal do
programa
 falhas no hardware, exaustão de recursos, erros
 Quando ocorre a condição excepcional
 uma exceção é lançada
 Manipulador de exceção
 Captura a exceção

10. Manipulador de exceções
Transferência de execução
programa
manipulador
de
exceções

11.  Problemas acontecem
 O arquivo não é encontrado
 O servidor cai
 Esgotamento de memória
 Mas como saber se o método é de risco?
 O que identifica um código que pode sofrer esta
situação excepcional?
Manipulação de exceções

12. MusicTest1.java
import javax.sound.midi.*;
public class MusicTest1 {
public void play() {
Sequencer sequencer = MidiSystem.getSequencer();
System.out.println(“Temos um sequenciador”);
}
public static void main(String args[]) {
MusicTest1 mt = new MusicTest1();
mt.play();
}
}

14. O que acontece quando
você usa método de risco???
 Você quer chamar um método de uma classe
que você não escreveu

15. O que acontece quando
você usa método de risco???
 O método faz algo arriscado, algo que talvez
não funcione em tempo de execução

16. O que acontece quando
você usa método de risco???
 Você precisa saber que está chamando um
método de risco

17. O que acontece quando
você usa método de risco???
 Você escreve o código que trata a falha, caso
ocorra. Você tem que estar preparado, neste
caso

18. “Algo ruim aconteceu.
Eu falhei”
 Mecanismo simples e claro
 Se um método pode falhar, ele deve declarar que
pode ocorrer a falha, assim é possível se precaver
 Como saber se um método lança uma
exceção???
  THROWS

19. O método getSequencer()

20. try/catch
 O compilador precisa saber que você sabe que
está se arriscando
public class MusicTest1 {
public void play() {
try {
Sequencer sequencer = MidiSystem.getSequencer();
System.out.println(“Temos um sequenciador”);
} catch (Exception e) { //manipulação }
}
public static void main(String args[]) {
MusicTest1 mt = new MusicTest1();
mt.play();
}
}

21. Manipulador de exceções
 try
 indica um bloco de código que pode lançar
exceções
 região protegida
 catch
 associa um tipo de exceção a um bloco de
código que pode tratá-la
 finally
 realiza código dependente do bloco try e
independente da exceção ser lançada

22. Manipulador de exceção
1. try {
2. // Primeira linha da região protegida
3. // que é controlada pela palavra-chave try
4. // Coloque aqui o código que pode lançar exceção
5. // Várias linhas ou apenas uma
6. }
7. catch(PrimeiraException) {
8. // Ponha o código que manipula a exceção
11. }
12. catch(SegundaException) {
13. // Ponha o código aqui que manipula a exceção
14. }
15.
16. // Códigos que não necessitam de proteção

23. Exemplo em pseudocódigo
try {
captureUmArquivoQueEstaNaRede
leiaArquivoePopuleaTabela
}
catch(NaoConsegueCapturarArquivoRedeException) {
usarArquivoLocal
}
continuaExecucao

24. Exemplo em pseudocódigo 2
try {
captureUmArquivoQueEstaNaRede
leiaArquivoePopuleaTabela
}
catch(NaoConsegueCapturarArquivoRedeException) {
usarArquivoLocal
} finally {
liberarArquivoUsado
}
continuaExecucao

25. Preparando o bolo
try {
prepararReceitaBolo
ligarForno
colocarBoloNoForno
}
catch(BoloQueimadoException) {
retirarBoloDoForno
} finally {
desligarForno
}

26. Manipulador de exceções
regras
 Após um bloco try
 um ou mais blocos catch
 ou um bloco finally
 blocos catch
 deve vir imediatamente um após o outro
 não pode haver blocos de código entre eles
 deve ser precedido de um try
 finally
 executa independente de ter sido lançada uma
exceção ou não
 deve ser precedido de um try ou de um try/catch

27. Formas válidas
try {
// executa algo
} finally {
// limpa o código
}
PODE

28. Formas válidas
try {
// fazerAlgo
} catch (AlgumaException ex) {
// manipular exceção
} finally {
// limpar
}
PODE

29. Formas válidas
try {
// fazer algo
}
System.out.println(
“fora do bloco");
NÃO PODE

30. Formas válidas
try {
// fazer algo
}
System.out.println(
“fora do bloco");
catch(Exception ex) { }
NÃO PODE

31. observação
pode-se omitir
o catch ou finally
mas
não é permitido
se omitir ambos

32. Propagando exceções não
capturadas

34. Propagando exceções

35. Propagando exceções
main()
metodo1()
metodo2()
metodoPerigoso()
try {
} finally {
}
exception

37. Definindo exceções

38. Definindo exceções
 Subclasses java.lang.Exception
try {
// algum código
}
catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}

39. Definindo Exceções
Object
Throwable
Error Exception
Runtime
Exception

40. Hierarquias de exceções
• Objetos que podem ser lançados e capturados
• define subclasses que representam situações
incomuns
• aplicações, em geral, não conseguem se recuperar
• causados por indisponibilidade de recurso
• condição exigida não satisfeita
• Geralmente indicam erros no programa
• Podem ser algum erro difícil de identificar

41. Manipulando as exceções
 Polimorfismo é válido na captura de exceções
 1 única cláusula catch pode capturar mais que
um tipo exceção
try {
//codigo que pode lancar
} catch (MinhaExcecao e) {
}
se esta exceção tiver subclasses, este bloco
catch será capaz de capturar exceções
deste tipo e de todas as subclasses

42. Dito isto
 O bloco abaixo captura qualquer exceção
try {
//codigo que pode lancar
} catch (Exception e) {
}
Provavelmente
não é a melhor opção.
Geralmente é preciso tratar as
exceções de forma distinta

43. Exceção sem subclasses
 Catches com exceções sem subclasses
 SÓ PODEM capturar aquele tipo
try {
//codigo que pode lancar
} catch
(StringIndexOutOfBoundsException e) {
e.printStackTrace();
}

44. Voltando às subclasses
RoupaException
CalcaException CamisaException
MangaLongaException QueroSerForteException

45. Voltando às subclasses
RoupaException
CalcaException CamisaException
MangaLongaException QueroSerForteExeption
Se um código é capaz de
lançar várias exceções de
uma mesma hierarquia
E se quiser manipular
cada uma individualmente
os blocos catches devem
tratar da mais específica
para mais geral

46. Códigos válidos
try {
maquinaDeLavar.lavarRoupa();
} catch (QueroSerForteException e) {
//Trata só os problemas da queroSerForte
} catch (CamisaException e) {
//Trata só os problemas de Camisa
} catch (RoupaException e) {
//Trata só os problemas de todo resto
}

47. Códigos válidos
try {
maquinaDeLavar.lavarRoupa();
} catch (MangaLongaException e) {
//Trata só os problemas da MangaLonga
} catch (CamisaException e) {
//Trata só os problemas de Camisa
} catch (RoupaException e) {
//Trata só os problemas de todo resto
}

48. Códigos válidos
try {
maquinaDeLavar.lavarRoupa();
} catch (CalcaException e) {
//Trata só os problemas da Calca
} catch (CamisaException e) {
//Trata só os problemas de Camisa
} catch (RoupaException e) {
//Trata só os problemas de todo resto
}

49. Códigos válidos
try {
maquinaDeLavar.lavarRoupa();
} catch (RoupaException e) {
//Trata o erro de todas as roupas do //
mesmo jeito
}

50. Inválido
try {
maquinaDeLavar.lavarRoupa();
} catch (RoupaException e) {
//tratamento
} catch (CamisaException e) {
//tratamento
} catch (QueroSerForteException e) {
//tratamento
}

52. A exceção é propagada
main()
metodo1()
metodo2()
metodoPerigoso() exception

53. Declaração de exceções

54. Métodos que lançam exceção
 Métodos que podem lançar exceção
 devem declarar que podem lançar a exceção
 a menos que sejam subclasses RuntimeException
 exceções verificadas
 a lista de exceções constituem a interface pública
do método
 Use o throws
void meuMetodo() throws Excecao1,
Excecao2 {
//codigo do método
}

55. verb to throw
Imperative
throw
Present
I
throw
you
throw
he throws
we
throw
you
throw
they
throw

56. Utilizando o meu método
tratando tudo
void meuMetodo() throws Excecao1, Excecao2 {
//codigo do método
}
void usarMeuMetodo() {
try {
meuMetodo();
} catch (Excecao1 e1) {
//tratamento
} catch (Excecao2 e2) {
//tratamento
}
}

57. Utilizando o meu método
tratando apenas 1 parte
void meuMetodo() throws Excecao1, Excecao2 {
//codigo do método
}
void usarMeuMetodo() throws Excecao2{
try {
meuMetodo();
} catch (Excecao1 e1) {
//tratamento
}
}

58. Utilizando o meu método
tratando apenas 1 parte
void meuMetodo() throws Excecao1, Excecao2 {
//codigo do método
}
void usarMeuMetodo() throws Excecao1{
try {
meuMetodo();
} catch (Excecao2 e2) {
//tratamento
}
}

59. Utilizando o meu método
e não tratando nada
void meuMetodo() throws Excecao1, Excecao2 {
//codigo do método
}
void usarMeuMetodo()
throws Excecao1, Excecao2{
meuMetodo();
}

60. A exceção é propagada
metodo1()
usarMeuMetodo()
meuMetodo() exception

61. Exceções

63. throws x throws
 throws
 Use a palavra reservada throws para declarar que
o método lança uma exceção
public void metodo1() throws Exception{
...
}
 throw
 Use a palavra reservada throw para lançar a
exceção
throw new Exception();

64. Um código
que pode lançar exceção
public class FoguetinhoMentosComCoca extends
Foguete {
private boolean explode;
public void misturarMentosComCoca()
throws ExplosaoException {
if (explode) {
throw new ExplosaoException();
}
}
}

65. Dica do livro
void doStuff() {
doMore();
}
void doMore() {
throw new IOException();
}
NÃO PODE

66. Dica do livro
void doStuff() {
doMore();
}
void doMore() throws IOException {
throw new IOException();
}
NÃO PODE

67. Dica do livro
void doStuff() {
try {
doMore();
} catch (IOException e) {
//tratamento
}
}
void doMore() throws IOException {
throw new IOException();
}
PODE

68. Exceções não verificadas
Exceções não
verificadas
Runtime
Exception
NullPointer
Exception
IndexOut
OfBound
Exception
Arithmetic
Exception

69. Exceções não verificadas
public class Teste {
public void metodoPode() {
throw new NullPointerException();
}
}
PODE

70. dica do livro
class MyException extends Exception {
void someMethod () {
doStuff();
}
void doStuff() throws MyException {
try {
throw new MyException();
}
catch(MyException me) {
throw me;
}
}
}

71. Quanto a classe Error
class TestEx {
public static void main (String [] args) {
metodoMau();
}
static void metodoMau() { //Não precisa declarar Error
fazerAlgo();
}
static void fazerAlgo() { //Não precisa declarar Error
try {
throw new Error();
}
catch(Error me) {
throw me; // Capturamos e relançamos
}
}
}

72. Erros e exceções comuns

73. Categorias de exceções
 Exceções da JVM
 Exceções ou erros que são exclusivos da JVM
 Exceções Programáticas
 Lançadas pelos aplicativos ou por
programadores

74. Exceções da JVM
 NullPointerException
 Lançada quando se tenta utilizar um variável de
referência nula
 Não como o compilador prever
 StackOverFlowError
 Lançada quando o SO fica sem espaço na RAM

75. Exceções lançadas
programaticamente
 Ver lista do livro