Algumas observacoes:O tipo da excecao declarada no catch devera ser compativel com a excecao esperada. Do contrario, o Java alertara que o erro nao esta sendo tratado. (Excecoes verificadas).Perceba tambem que existe uma hierarquia permitida para declaracao de varios catch's. Caso seja necessario declarar varios catch's procure comecar com as classes filhas e posteriormente ir para as classes mais genericas.Resumo das Exceptions.Object | |-- ... | |-- Throwable | |-- Error (Nao verificadas) | | | |-- ... | |-- Exception | |-- ... (Verificadas) | |-- RuntimeException (Nao verificadas) | |-- ...Veja em: http://download.oracle.com/javase/6/docs/api/java/lang/package-tree.htmlE preciso importar a classe da excecao utilizada, no caso de excecoes que nao forem do pacote java.lang.import java.io.*;class TestException4{ public static void main(String[] args){ try{ throw new FileNotFoundException(); //throw new IOException(); // Procure ir "afunilando" a captura de excecoes... } catch(FileNotFoundException f){ f.printStackTrace(); // IOException e superclasse de FileNotFoundException, por isso, caso // necessaria deve ser inserida posteriormente... } catch(IOException i){ i.printStackTrace(); // .. a menos que nao fizerem parte da mesma hierarquia direta. // RuntimeException nao herda de IOException }catch(RuntimeException r){ r.printStackTrace(); }finally{ System.out.println("...liberando recursos!"); } }}..inverta os catch's acima para enteder melhor a necessidade da ordem de precedencia. Tratando a excecao ou delegando o tratamento..Voce pode ainda optar por tratar ou transferir o tratamento para um metodo chamador.Caso opte por tratar, e so usar a estrutura try/catch/finally, caso nao, tera que declarar na interface do metodo o tipo da excecao lancada. Desta forma, o processamento e interrompido e o controle e passado para o metodo chamador.Observe o codigo abaixo.class TestException2{ public static void main(String[] args){ try { System.out.println("...iniciando o metodo main!"); testException1(); //System.out.println("..tentando executar este codigo!"); // nunca sera executado. } catch(Exception e){ System.out.println("..catch do main!"); } // Gracas ao tratamento que foi feito, conseguimos pelo menos terminar // a thread. System.out.println("..finalizando metodo main()"); } static void testException1() throws Exception{ testException2(); System.out.println("..finalizando metodo testException1()"); } static void testException2() throws Exception{ try { testException3(); } catch (Exception ex){ ex.printStackTrace(); } finally { System.out.println("..finalizando metodo testException2()"); } } static void testException3() throws Exception{ testException4(); System.out.println("..finalizando metodo testException3()"); } static void testException4() throws Exception{ throw new Exception("Metodo 4"); //System.out.println("..finalizando metodo testException4()"); }}Em um sequencia de chamadas de metodos, uma excecao e lancada no topo da pilha. O ultimo metodo nao trata a excecao passando o controle para o seu metodo chamador e assim sucessivamente. Note que antes de chegar no metodo main a excecao e tratada, porem, o metodo (testException2) declara uma Exception, o que obriga a alguem, abaixo na pilha a se preocupar com um possivel tratamento, mesmo que nenhuma excecao seja transferida.Por fim, observe que nenhuma excecao foi transferida mesmo, pois o catch do main nao foi processado. Mas como o metodo testException2 alertou sobre a Exception em potencial, e testException1 transferiu o tratamento, sobrou para main tratar. Personalizando suas ExceptionsEm alguns caso, voce podera ainda, criar suas proprias excecoes.E como tudo em Java e heranca (ou interfaces, ;)) essa classe devera herdar de um tipo existente de classes. Cabera ao programador decidir se o novo tipo sera uma excecao ou erro. Caso excecao, se sera