Monday, January 29, 2007

How do exceptions work?

Now let us understand how Exceptions work. The code shown below is a simple program that shows how to use Exceptions. Listen to the audio below as you view the code.


import java.io.*;

public class LearningExceptions {
  public static void main(String args[]) {
    LearningExceptions le = new LearningExceptions();
    System.out.println("Hello, this is a test program to
      understand Exceptions");
    try {
      System.out.print("Please enter your name: ");
      String name = le.getName();
      System.out.println("Hey " + name + " how are you doing?");
    catch(IOException ioe) {
      System.out.println("Looks like the standard input
        stream does not like you!");
    }
  }

  private String getName() throws IOException {
    BufferedReader br = new BufferedReader
      (new InputStreamReader(System.in));
    return(br.readLine());
  }
}
Java2html

 

Now let us compare how error handling is done with and without Exceptions. The PSEUDOCODE shown below has two methods: the first one is called aFunctionWithoutExceptions(), and the second one is called aFunctionWithExceptions(). As their names suggest the first method does error handling, the old way, by inspecting return values, and the second method does error handling with Exceptions.

//PSEUDOCODE
aFunctionWithoutExceptions() {
  doSomething1
  checkIfSomethingWentWrong
  doSomething2
  checkIfSomethingWentWrong
  doSomething3
  checkIfSomethingWentWrong
}

aFuntionWithExceptions() {
  try {
    doSomething1
    doSomething2
    doSomething3
  catch(ExceptionTypeA e1) {
    handle the exception
  catch(ExceptionTypeB e2) {
    handle the exception
  }
}
Java2html

 

When inspecting return values: 

  • We have to check for the return value after every function call. This increases code and also reduces readability of the code .
  • Error handling code is interspersed with program code.
  • Checking for the meaning of an error code will usually require long if...else statements.

When using Exceptions:

  •  We do not have to inspect the return value after every method call. We just invoke the method and if an Exception is thrown, control will automatically transfer to the appropriate Exception handling code.
  • Error handling code is in a distinct region (the catch block) and is not interspersed with program code.
  • We do not need to specifically check what an error code means. Since we throw unique Exceptions for unique problems, control will automatically be trasnferred to the appropriate catch block.
Note that we have two catch blocks in the second method. Whenever the statements in the try block are capale of throwing multiple Exceptions, we must catch all of them, either in a generic catch block that catches the superclass of all Exceptions "java.lang.Exception", or in individual catch blocks. It is advised to adopt the latter style.


Notes: This text was originally posted on my earlier blog at http://www.adaptivelearningonline.net

No comments: