Why specifying an exception???

Question

What are the benefits of specifying what kind of exception you are catching as:
try{
    //do something
} catch(RemoteException e){
    e.printStackTrace();
why not
try{
    //do something
} catch(Exception e){
    e.printStackTrace();
RemoteException or Exception... Exception works with all type of exepctions but why should I specify as "RemoteException"???

Answer 1

jschell wrote:
emailkia wrote:
Thank you jduprez for your reply...
but we say I am not intressted of giving any message about RemoteException or do anything about it then "Exception" would be good enough to use??? Because if I am only reading the logg for exception, e.printStackTrace() would provide me complete information about the exception no matter if I use "RemoteException" or "Exception". Am I right?You catch exceptions because you are going to do something with them or because of them.
You don't catch them if you are not going to do something with them.
In general logging is NOT sufficient for catching an exception. It still must do something else. Such as return a default value or throw a different exception.Although there are cases where it's appropriate to just catch and log. For instance, in a top-level processing loop, if processing one element shouldn't stop the loop from continuing on to the next element. However, even in those cases, you'd probably want to catch individual checked exceptions (or root-level checked exceptions by family) individually, and then catch RuntimeExeption to grab all the non-Error unchecked exceptions, and, then maybe Error.
while (!done) {
  try {
    process();
  catch (IOException ex) {
    // log it, possibly handle it
  catch (InterruptedException ex) {
    // log it, possibly rethrow, or call Thread.currentThread().interupt()
  catch (RuntimeExcetpion ex) {
    // log it
  // Maybe, maybe not include the following
  catch (Error ex) {
    // log it
}This way, your main processing loop will continue even if there's a problem, but you're not blindly catching all checked exceptions. If the underlying process() routine adds a new checked exception to its throws clause, you'll be made aware of it next time you compile, and will have to deal with it. If you just caught Exception, that would not be the case.