Exceptions - Musings

By: Nicholas Duchon.

Exceptions? Here is a quick introduction to the key points. 

• Exceptions may be thrown by methods.
• Exception classes hierarchy:
  • The predefined hierarchy of classes under Throwable - see the following for a summary: 

    • All Exceptions 8.0

  • Child classes of Error and RuntimeException are unchecked, all others are checked.
    
  • Checked means the compiler will enforce explicit handling either in a try/catch block or by rethrowing the exception.
  • A programmer may add an exception class as one would add any other class to the predefined hierarchy.
    
  • As with all classes, one should be careful to extend the appropriate class.
  • There are two basic pieces of information in the exception: its class and a String.
    
  • The latter is some kind of message that might/should be helpful to the user of the method (the programmer) or perhaps even the end user of the program.
• Instantiating exceptions
  • Since they are objects, they are new'ed as any other object, typically in response to a method detecting something going very wrong, such as divide by zero or file not found, which the method is not built to handle. The method's solution is to send a message to the caller of the method indicating the failure (the class of the exception) and something about the nature of the failure (the exception's String description). 
• Throwing an exception
  • The code is very simple:
    throw new MyException ("I am having a problem");
  • The declaration of a method throwing an exception must explicitly say that it can throw this class of exceptions by saying:
    throws MyException.
    This tells the compiler that any method that calls this method will have to handle this exception explicitly if the exception is checked (see above).
• Handling an exception
  • Let's say method myA() calls myB(), and myB() throws some exception. Here are the cases:
  • The exception is unchecked -
    
  • in which case mA() MAY handle the exception in a try/catch block.
  • The exception is checked - so two cases:
    • myA() handles the exception by rethrowing it, so the problem is escalated, and if no program code handles it, the JVM will crash gracefully
    • myA() handles the exception in a try/catch block - end of story
  • Methods in the Throwable class:
  • getMessage () - the String used in the original throw
    
  • getStackTrace () - an array of StackTraceElement
  • printStackTrace ([PrintStream | PrintWriter]) - no parameter prints to console
  • toString () - typically more information than getMessage ()
• Examples:
• See below
  
• Prefix Example

Code Example:

public class DivZeroTest {
  public static void main (String [] args) {
    try {
      int k = 1, j = 0;
      System.out.println ("Div: " + k/j);
    } catch (ArithmeticException e) {
      System.out.println ("Exception: " + e);

      System.out.println ("\n***** e.getMessage ():");
      System.out.println ("Exception: " + e.getMessage());

      System.out.println ("\n***** Thread.dumpStack ():");
      Thread.dumpStack ();

      System.out.println ("\n***** e.printStackTrace ():");
      e.printStackTrace ();
    } // end try/catch
  } // end main
} // end class DivZeroTest

Output:

Exception: java.lang.ArithmeticException: / by zero

***** e.getMessage ():
Exception: / by zero

***** Thread.dumpStack ():
java.lang.Exception: Stack trace
    at java.lang.Thread.dumpStack(Thread.java:1329)
    at DivZeroTest.main(DivZeroTest.java:11)

***** e.printStackTrace ():
java.lang.ArithmeticException: / by zero
    at DivZeroTest.main(DivZeroTest.java:5)

ND.