Ordem das Exceptions

Programação Java
#1

oi pessoal

em meu projeto eu tenho alguns try/catch que sem eu perceber acabaram ficando “aninhados”. Conheço a regra correspondência de excessões, que IOException não pode ser tratada antes de uma FileNotFoundException, por IOE… ser mais abrangente. A regra diz que primeiro trato File… e depois se precisar IOE…

Minha dúvida é porque como disse os try´s ficaram aninhados a medida que fui adicionando código e no final ficou assim:

try // fnfe
{
   iaLog = new BufferedReader(new FileReader("C:/Log.txt"));
   try // ioe
   {
      while ((iaAudit = iaLog.readLine()) != null) 
      {
      //um montão de coisas aqui no meio
      }
   } 
   catch (IOException ioe) 
   {
      ioe.printStackTrace();
   }
} 
catch (FileNotFoundException fnfe) 
{
   fnfe.printStackTrace();
}

Como pode ver tem um try/catch que trata da FNFE e dentro deste try tem outro try que trata da IOE.
Funciona, mas é correto fazer isso do ponto de vista de boas práticas de programação? Eu sei o que o código faz e porque faz, mas alguém que não conhece, vai achar estranho e ficar perdido por causa disso?

Outra pergunta. Como eu estou me preparando para a scjp6, isso pode cair na prova? o que eu responderia? vale, não vale?

valeu

#2

eu deixaria o meu código assim

[code] try
{
iaLog = new BufferedReader(new FileReader(“C:/Log.txt”));

      while ((iaAudit = iaLog.readLine()) != null)   
      {  
      //um montão de coisas aqui no meio  
      }

}
catch (Exception e) {
e.printStackTrace();
} [/code]

o que ele pegar ele vai log no console tanto se for IOException ou FileNotFoundException

rsrsrsrsrsrsrs

#3

[quote=java es a lei]eu deixaria o meu código assim

[code] try
{
iaLog = new BufferedReader(new FileReader(“C:/Log.txt”));

      while ((iaAudit = iaLog.readLine()) != null)   
      {  
      //um montão de coisas aqui no meio  
      }

}
catch (Exception e) {
e.printStackTrace();
} [/code]

o que ele pegar ele vai log no console tanto se for IOException ou FileNotFoundException

rsrsrsrsrsrsrs [/quote]

Também vai pegar qualquer outro erro que você não queria que pegasse.

#4

Valer vale hehehe, a SCJP vai testar se você sabe o que está acontecendo no código e se você ver um código assim vai saber que a FNFE se refere ao código new FileReader(…
E a IO se refere ao readLine.

Agora sua dúvida quando a padrões eu acho que ficou meio estranho… Vendo seu comentário //um montão de coisas aqui no meio, eu acho que o new FileReader vai ficar muito perdido lá em cima… O que você pode fazer é colocar o catch de FNFE antes do segundo try, ou então aninhar os catchs em um só try, lembrando de manter hierarquia…

Acho a segunda opção bem melhor, olha como ficariam os códigos:

try {
   iaLog = new BufferedReader(new FileReader("C:/Log.txt"));
} catch (FileNotFoundException fnfe) {
     fnfe.printStackTrace();
}
try {
   while ((iaAudit = iaLog.readLine()) != null) {
   //um montão de coisas aqui no meio
   }
}  catch (IOException ioe)   {
      ioe.printStackTrace();
}

ou

try {
   iaLog = new BufferedReader(new FileReader("C:/Log.txt"));
   while ((iaAudit = iaLog.readLine()) != null) {
   //um montão de coisas aqui no meio
   }
}  catch (FileNotFoundException fnfe) {
      fnfe.printStackTrace();
}  catch (IOException ioe)   {
      ioe.printStackTrace();
}
#5

O que mais cai na SCJP é saber se o programa compila se os exceptions forem colocados nesta ordem

try {
   iaLog = new BufferedReader(new FileReader("C:/Log.txt"));
   while ((iaAudit = iaLog.readLine()) != null) {
   //um montão de coisas aqui no meio
   }

} catch (IOException ioe)   {
      ioe.printStackTrace();

} catch (FileNotFoundException fnfe) {
      fnfe.printStackTrace();
}

Não compila pois IOException é uma exceção mais genérica que FileNotFoundException, nunca cairia no segundo. A ordem é sempre da exceção mais específica para a mais genérica.

#6

valeu pelas dicas

Porém minha questão é que quando tinha os try/catch aninhados cada try trataria de sua exceção no catch correspondente. A primeira sugestão do Bruno é excelente porque cada trecho de código teria um try/catch proprio porém não atende o que eu preciso fazer. Pelo fato de serem muitos ficaria poluído o código com try/catch vazando pelo ladrão.

Fiz as mudanças sugeridas por vocês e ai ficou assim, um monte de catch tratando de várias exceções.

Pelo que entendi do que vocês comentaram, esta seria a melhor maneira quando tenho tantas possibilidades de erro.

try { //........... } catch (ClassNotFoundException cnfe) { cnfe.printStackTrace(); } catch (SQLException sqle) { sqle.printStackTrace(); } catch (InstantiationException ie) { ie.printStackTrace(); } catch (MalformedURLException mue) { mue.printStackTrace(); } catch (IOException ioe) { ioe.printStackTrace(); } catch (AgletException ae) { ae.printStackTrace(); }

#7