Tutorials : Using Chained Exceptions in JDK 1.4 :

Using Chained Exceptions in JDK 1.4

A new Feature in JDK 1.4

The new JDK 1.4, which was released a few months ago, contains several very useful features which will help the programmer making more robust applications. In this article I'll look at one of the features--the extension to the Throwable class which makes "exception chaining" possible. Look in the resources section at the end of the article for links to information on other new features in JDK 1.4.

If exception chaining is new to you, you might benefit from first reading my Javaboutique article " Using your own exception classes in Java" on the subject. In short, exception chaining reflects the actual method calling sequence when a severe error is detected by storing an instance of the Exception class for each method call. The useful thing about this is that it allows the programmer to store essential information--in each instance of the Exception class--pertaining to the error situation.

Before JDK 1.4 you'd have to build the exception chaining mechanism yourself. By subclassing the Exception class you could add the member variables that you needed for storing data and also for storing the link to the chained exception. With JDK 1.4 this is no longer necessary.

A "mean" Calculator

To illustrate exception chaining in JDK 1.4 we'll build a small demo example, which is refined in small steps. The program doesn't do anything useful--it simply illustrates the various techniques that I'll go through. The Java program takes an array of values and calculates the arithmetic mean. In order to have a chain of method calls I've separated the logic in small chunks of code:

package hansen.playground;

public class GetMean {
  
  public static void main(String[] args) {
    float[] v = {1,2,3};
    float f = new GetMean().mean(v);
    System.out.println(f);
  }
  
  private float mean(float[] w) {
    return divide(sum(w), w.length);
  }
  
  private float sum(float[] s) {
    float f = 0;
    for (int i = 0; i < s.length; i++) f += s[i];
    return f;
  }
  
  private float divide(float a, float b) {
    if (b == 0) throw new RuntimeException("Division by zero");
    return a / b;
  }
  
}

As you can see "main" calls "mean" which calls "sum" and "divide". "divide" is the interesting method, since it may throw an Exception. I have for this example chosen to use an unchecked exception, but you may also use a checked exception, like the Exception class. It's a matter of taste which you prefer--see my closing comments for more on this.

If the above example is run we get the result "2.0" printed out. If we now replace the statement

float[] v = {1,2,3};

with

float[] v = {};

and run the program again we'll get:

java.lang.RuntimeException: Division by zero
  at hansen.playground.GetMean.divide(GetMean.java:22)
  at hansen.playground.GetMean.mean(GetMean.java:12)
  at hansen.playground.GetMean.main(GetMean.java:7)
Exception in thread "main"

This nicely reflects the calling sequence of the methods, but it doesn't tell us much about the data in our program. In a program as simple as this there is not much to show, but in real applications there'll always be a lot of information that could be useful to a programmer or the support people, when trying to locate an error.

Catch the Exception

If we wanted to print out the contents of the array "w" in method "mean", we could do so by first try-catching the exception:

private float mean(float[] w) {
  try {
    return divide(sum(w), w.length);
  } catch (RuntimeException r) {
    throw new RuntimeException("w contains [" + toString(w) + "]");
  }  
}

"toString" simply concatenates the array values--see the complete program here. When we run the modified program we get this written out:

java.lang.RuntimeException: w contains []
  at hansen.playground.GetMean2.mean(GetMean2.java:15)
  at hansen.playground.GetMean2.main(GetMean2.java:7)
Exception in thread "main"

This was what we wanted--we can see that the array is empty--but we "lost" the "Division by zero" message and the full traceback, which generally is nice to have.

Applet Index
(sorted alphabetically)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z #s

The Java Source
(applets w/source code)
A B C D E F G H I J K
L M N O P Q R S T U
V W X Y Z

How to Add Java Applets to Your Site

New on the Java Boutique:

New Review:

Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling API boasts simplicity, ease-of-integration, a well-rounded feature set, and it's free!

New Applet:

Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA sequences into three useful formats.