Uma exceo uma condio anormal que surge durante a execuo de uma sequncia de cdigos.

. Como quase tudo em Java, exceo tambm um objeto. O mtodo que causou o erro tem 2 opes: Manipular a exceo Passar adiante

 Uma exceo pode ser gerada: Pelo prprio Java, em tempo de execuo Pelo prprio cdigo

Iremos neste tpico conhecer as 5 palavras-chave para a manipulao de exceo em Java: try, catch, throw, throws e finally.

try { //Aqui ser a regio a ser monitorada. //Contero os cdigos que podero gerar erros. } catch (DeuProblemaException dpE) { //Aqui vir o manipulador da exceo em questo } catch (AlgoDeuErradoException adeE) { //Outro manipulador, dessa vez para tal exceo } //... finally { //bloco de cdigo que ser executado aps os blocos //try serem finalizados. }

 Todos so subclasses de Throwable. Abaixo de Throwable, encontram-se 2 subclasses que dividem as excees em dois ramos: Exception e Error. Exception possui uma importante subclasse, RuntimeException

Object

Serializable

Throwable

Exception

Error

RuntimeException

 Vamos entender o que acontece quando no manipulamos as excees. class Exemplo1 { public static void main(String[] args) { int d = 0; int a = 40/d; //tentando dividir por zero. } }
java.lang.ArithmeticException: / by zero at Exemplo1.main(Exc0.java:4)

 Outro exemplo: class Exemplo1 { static int dividirPorZero(int x, int y) { return x / y; } public static void main(String[] args) { dividirPorZero(10, 0); } }
java.lang.ArithmeticException: / by zero at Exemplo1.dividirPorZero(Exc1.java:3) at Excmplo1.main(Exc1.java:6)

 Benefcios da manipulao manual de excees Possibilita que o prprio programador fixe o erro. Previne o fim automtico do programa. Primeira providncia: coloque o cdigo a ser monitorado dentro do bloco try e, imediatamente a seguir, inclua a clusula catch.

class Exemplo2 { public static void main(String[ ] args) { int d, a; try { //Incio do monitoramento d = 0; a = 42 / d; System.out.println(No ser impresso); } catch (ArithmeticException e) { //Pegou a exceo System.out.println(Diviso por zero!); } System.out.println(Fim do bloco do tratamento); } }

import java.util.Random; class Exemplo3 { public static void main(String[ ] args) { int a = 0, b = 0, c = 0; Random r = new Random( ); for (int i = 0; i < 32000; i++) { try { b = r.nextInt( ); c = r.nextInt( ); a = 12345 / (b/c); } catch (ArithmeticException e) { System.out.println(Diviso por zero!); //System.out.println(Exceo: +e); //Seta a para zero e continua a = 0; } System.out.println(a : + a); } } }

 Vrias excees podem surgir em um cdigo. Quando uma exceo lanada, cada catch inspecionado na sua devida ordem. Os demais catch so passados e a execuo continua aps os blocos try-catch.

class Exemplo4 { public static void main(String[ ] args) { try { int a = args.length; System.out.println(A = + a); int b = 42 / a; int[ ] c = {1}; c[49] = 99; } catch(ArithmeticException e) { System.out.println(Diviso por zero +e); } catch (ArrayIndexOutOfBoundsException e) { System.out.println(Posio inexistente, +e); } System.out.println(Executado aps os blocos); } }

class Exemplo5 { public static void main(String[ ] args) { try { int a = 0; int b = 42 / a; } catch (Exception e) { System.out.println(Catch genrico... ); }catch (ArithmeticException e) { System.out.println(Isso nunca ser executado); } } }

 Uma declarao try pode ser aninhada. Se um try interno no possuir um manipulador catch para uma exceo em particular, a pilha desenrolada e os prximos manipuladores catch da declarao try so inspecionados. Caso nenhum catch bata com o tipo de exceo, o prprio Java ir manipul-la.

class Exemplo6 { public static void main(String[ ] args) { try { int a = args.length; int b = 42 / a; System.out.println(A = + a); try { if (a == 1) a = a / (a a); if (a == 2) { int [ ] c = {1}; c[42] = 99; } } catch(ArrayIndexOutOfBoundsException e) { System.out.println(Posio inexistente + e); } }catch (ArithmeticException e) { System.out.println(Diviso por zero +e); } } }

class Exemplo7 { static void testarMaisCoisas(int a) { try { if (a == 1) if (a == 2) {

a = a / (a-a); int[ ] c = {1}; c[99] = 10;

} } catch (IndexOutOfBoundsException e) { System.out.println(Fora dos limites + e); } } public static void main(String[ ] args) { try { int a = args.length; int d = 42 / a; System.out.println(A = +a); testarMaisCoisas(a); }catch (ArithmeticException e ) { System.out.println(Diviso por zero! + e); } }

 perfeitamente possvel para um programa lanar explicitamente uma exceo. Sintaxe: throw instanciaThrowable;

Existem 2 formas para obtermos um objeto throwable: 1) usando um parmetro em uma clusula catch 2) criando um objeto novo, com o operador new.

class Exemplo7 { public static void main(String[ ] args) { try { metodo1( ); } catch (NullPointerException e) { System.out.println(Recapturada.. +e); } } static void metodo1( ) { try { throw new NullPointerException(demo); } catch(NullPointerException e) { System.out.println(Pega dentro de mtodo1); throw e; } } }

 Os mtodos que chamam aqueles que no manipulam uma exceo, devero estar cientes que eles no o fazem.

Na declarao do mtodo dever constar a clusula throws. Todas as excees que um mtodo poder lanar devero ser declaradas na clusula throws.
Sintaxe: tipo nomeDoMetodo(parametros) throws lista-exceo

class Exemplo8 { public static void main(String[ ] args) { lancar( ); } static void lancar( ) { System.out.println(Dentro de lanar!); throw new IllegalAccessException(exemplo8); } }

class Exemplo9 { public static void main(String[ ] args) { try{ lancar( ); }catch(IllegalAccessException e) { System.out.println(Exceo pega! + e); } } static void lancar( ) throws IllegalAccessException { System.out.println(Dentro de lanar!); throw new IllegalAccessException(exemplo8); } }

 O finally cria um bloco de cdigo que ser executado aps o bloco try / catch ser completado e antes do cdigo que segue o bloco try / catch.

O bloco ser executado havendo ou no o lanamento de exceo.

Elemento opcional.

class Exemplo10 { static void processoA( ) { try { System.out.println(Dentro de A); throw new RuntimeException(demo); } finally { System.out.println(Final do processo A); } } static void processoB( ) { try { System.out.println(Dentro de B); return; }finally { System.out.println(Fim do processo B); } } }

...continuao public static void main(String[ ] args) { try{ procA(); }catch(RuntimeException e) { System.out.println(Exceo pega!); } } }
SADA: Dentro de A Final do processo A Exceo pega!

...continuao public static void main(String[ ] args) { try{ procA(); }catch(RuntimeException e) { System.out.println(Exceo pega!); } } }
SADA: Dentro de A Final do processo A Exceo pega!

 O Java define vrias classes de exceo dentro do pacote java.lang. As mais gerais delas so subclasses de RuntimeException que, como j vimos, no precisaro serem includas na listagem do throws. Essas excees so chamadas de unchecked. As excees checked so aquelas que no herdam de RuntimeException e devero estar na listagem throws, caso o mtodo em questo no a manipule.

Para criar excees personalizadas/customizadas, o primeiro passo subclassear Exception (que subclasse de throwable). A classe Exception no define quaisquer mtodos. Ao contrrio, ela herda os mtodos oferecidos por throwable. Dessa forma, todas as excees (inclusive aquelas que ns criamos), possuem tais mtodos. possvel (claro) sobrescrev-los nas classes de exceo que voc criar.

A classe Exception define 4 construtores. Veremos dois deles agora: Exception( ); Exception (String s);

class MinhaExcecao extends Exception { private int detalhes;

MinhaExcecao(int a) { detalhes = a; } public String toString( ) { return Minha Exceo[ + detalhes + ]; } } class Exemplo12 { static void computador(int a) throws MinhaExcecao { if (a > 10) throw new MinhaExcecao(a); System.out.println(Sada normal); } public static void main(String[ ] args) { try { computar(1); computar(20); } catch(MinhaExcecao e ) { System.out.println(Pega! + e); } } }

Permite-nos associar outra exceo com uma exceo. A segunda exceo descreve a causa da primeira exceo. Para permitir excees encadeadas, foram adicionados dois construtores em throwable: Throwable (Throwable causeExc) Throwable (String msg, Throwable causeExc) Os mtodos para exceo encadeada adicionados em Throwable so: Throwable getCause( ) Throwable initCause(Throwable causeExc )

class Exemplo11 { public static void main(String[ ] args) { try { demo( ); } catch(NullPointerException e) { System.out.println(Exceo pega! + e); System.out.println(Causa original: + e.getCause( )); } } static void demo( ) { NullPointerException e = new NullPointerException(camada top); e.initCause(new ArithmeticException(causa)); throw e; } }

Com a JDK 7, vieram 3 recursos interessantes e muito teis para o sistema de excees. Em nossos estudos, focaremos multi-catch.

class Exemplo12 { public static void main(String[ ] args) { int a = 10, b = 0; int[ ] vals = {1, 2, 3}; try { int resultado = a / b; //gera uma ArithmeticException //vals[10] = 99; gera IndexOutOfBoundsException }catch(ArithmeticException | ArrayIndexOutOfBoundsException e) { System.out.println(Exceo pega! +e); } System.out.println(Samos do multi-catch); } }