NullPointerException npe = null;
try {
} catch (NullPointerException e) {
  npe = e;
}

Exception

Finally, you could cast the caught exception to the new kind you want. I havn't tested this, so use caution:

IllegalAccessException iae;
try {
  throw new NullPointerException("Info here");
} catch (NullPointerException npe) {
  iae = (IllegalAccessException)((Exception)npe);
}

http://java.sun.com/products/jdk/1.2/docs/api/java/sql/SQLException.html

The following resource may be helpful also -

http://www.javaworld.com/javatips/jw-javatip91.html

1. 
   If all you really want to do is preserve the message of the exception, it is really easy. Your method would look something like:
   

   
   public void doSomething() throws IOException {
     try {
       // do something that may throw an SomeOtherException
     }
     catch (SomeOtherException e) {
       throw new IOException(e.getMessage());
     }
   }
   

   
   Of course, this only makes since if SomeOtherException somehow pertains to IO failure.
   

   
   



2. Another alternative is to create your own excpetion class that is a wrapper around another exception, or even a collection of exceptions. This could come in handy for situations where you may need to release resources upon an exception, but releasing these resources can also throw an excpetion. This is very common in JDBC and file I/O.
   

   
   For example, take this code snippet:
   

   
   public Student getStudent(int id) throws SQLException {
     try {
       // JDBC code here...
     }
     catch(SQLException e) {
       // rethrow
       throws e;
     }
     finally {
       // always release Connection, but this can throw Exception!
       try {
         //release
       }
       catch(SQLException e) {
         // hide. BAD!!!!
       }
     }
   }
   

   
   If we throw the second exception, we lose the first one - the last exception thrown is the one that propogates up the thread. But, if we throw the original one, we lose the second one. What to do...
   

   
   Well, we can create another class, such as SQLWrapperException:
   

   
   public class SQLWrapperException {
     private java.util.List exceptions;
   
     public SQLWrapperException(java.util.ListList exeptions) {
       this.exceptions = exceptions;
     }
   
     public java.util.List getExceptions() {
       return exceptions;
     }
   }
   

   
   Now we have a structure that can collect all our excpetions. Now, the method would look like:
   

   
   public Student getStudent(int id) throws SQLWrapperException {
     List exceptions = new List();
     try {
       // JDBC code here...
     }
     catch(SQLException e) {
       exception.add(e);
     }
     finally {
       // always release Connection, but this can throw Exception!
       try {
         //release
       }
       catch(SQLException e) {
         exception.add(e);
       }
       if (exceptions.size() != 0) {
         throw new SQLWrapperException(exceptions);
       }
     }
   }
   

   
   While this is a pretty simplistic example, I think you get the picture. You can also create a very generic container, such as ExceptionWrapper or ExceptionListWrapper, that can hold any type of exception.