1.9.3 Exceptions as Errors
Keywords: current

Next: 1.9.4 Name and Method Up: 1.9 Loose Ends Previous: 1.9.2 Casts and Static

##
1.9.3 Exceptions as Errors

Some operations on data are inherently partial. For example, there is no mathematically sensible definition for the result of integer division by zero. Similarly, there is no sensible definition for the first element of an empty sequence. Java provides an elegant mechanism for coping with this problem. Program operations can ``throw'' a ``run-time error'' condition called an unchecked exception that aborts program execution and prints a diagnostic error message and a list, called a traceback, of the stack of pending method calls. For example, attempting to divide any `int` by 0 generates an `ArithmeticException`. Exceptions are ordinary Java data objects descended from the built-in class called `Exception`. Unchecked exceptions are descendants of the class `RuntimeException` extending `Exception`.

In Java, any method can ``throw'' an exception simply by executing the statement

> `throw` ;

where is any expression that evaluates to an object of type `Exception`. The classes `Exception` and `RuntimeException` both include a zero-ary constructor and a unary constructor. The latter takes an error message `String` as an argument. The string argument is printed as a diagnostic message if it is provided.

The following Java code implements ``functional'' lists of objects:

    abstract class List {

      abstract Object first();
      abstract List rest();

      abstract String toStringHelp();
      // List -> String without enclosing parentheses and leading blanks
    }

    class Empty extends List {

      Object first() {
        throw new
          ClassCastException("first requires a non-Empty List");
      }
      List rest() {
        throw new
          ClassCastException("rest requires a non-Empty List");
      }
      public String toStringHelp() { return "()"; }
      String toStringHelp() { return ""; }
    }

    class Cons extends List {
      Object first;
      List rest;

      Cons(Object f, List r) {
        first = f;
        rest = r;
        }

      Object first() { return first; }

      List rest() { return rest; }

      public String toString() { return "(" + first + rest.toStringHelp() + ")"; }
      String toStringHelp() { return " " + first + rest.toStringHelp(); }
    }

The class `ClassCastException` is a built-in Java class extending `RuntimeException` that other built-in Java classes use to signal improper method applications where `this` or some other argument belongs to the wrong class.

`Exception` objects that do not belong to the type `RuntimeException` are called checked exceptions. We will discuss how they are used later in this monograph.

Next: 1.9.4 Name and Method Up: 1.9 Loose Ends Previous: 1.9.2 Casts and Static