Lecture Notes: Exceptions

Overview

Java's API makes very heavy use of throwing errors and exceptions. In this sense it is quite similar to Python (less so for C++). Formally, there is a Throwable class that serves as the base class for anything that can be thrown. There are two distinctsubclasses of Throwable:

• Error
  Errors are used to indicate serious problems. Some subclasses include OutOfMemoryError, InstantiationError. Errors are typically fatal, less directly related to the immediate programming command, and therefore rarely caught by a typical programmer.


• Exception
  Exceptions describe other problematic situations that are more directly the result of a programmer's mistake, or more likely to be expected for a given situation. Typical exceptions include:
  • NullPointerException
    
  • IndexOutOfBoundsException
    ArrayIndexOutOfBoundsException
    StringIndexOutOfBoundsException
    
  • IllegalArgumentException
    

Throwing an exception

public static double sqrt(double val) {
  if (val < 0)
    throw new IllegalArgumentException("Must be non-negative integer");

Catching an exception

The syntax for catching a possible error or exception is to shield the possibly offending command within a try/catch clause, as:

try {
  // one or more possible commands
} catch (exceptionType e) {
  // reaction to this exception
} catch (anotherExceptionType e2) {
  // reaction to that exception
}

FileInputStream f = null;
while (f == null) {
  String filename = scanner.next();    // assuming scanner is appropriate Scanner
  try {
    f = new FileInputStream(filename);
  } catch (FileNotFoundException e) {
    System.out.println("Could not find file " + filename);
  }
}

Optionally, a try clause may also end with a finally clause. That body will be executed in all situation, that is immediately after the successful completion of the try body, or after the catching of any declared exceptions. The book gives an example of the use of a finally clause to close a file reader.

Exception hierarchy and checked exceptions

Java defines a further refinement of Exception subclasses, by making a distinction between a RuntimeException hierarchy, and all other exceptions. In general, something is a RuntimeException if it is more easily preventable by proper programming techniques. For example, and ArrayIndexOutOfBoundsException is a subtype of RuntimeException as programming logic can be used to avoid causing such an exception.

An example of a class of exceptions that do not qualify as being a RuntimeException is the IOException class. Those problems tend to be caused by something external to the program logic, such as a file that cannot be found, open, or read.

The distinction between RuntimeException and others is an important one in the language definition, as RuntimeException types are treated as "unchecked" exceptions, while others are "checked" exceptions.

Throws declaration

public void read(String filename) throws IOException, ClassNotFoundException {
  // ...
}

The signficance of such required declaration of throwables is that it allows a caller to know precisely what types of checked exceptions might occur, and therefore a suggestion that such exceptions might be caught from the calling context. So if one function makes a call to one with declared throwables, the calling function must either guard such statements in a try/catch structure, or else add declarations in its own signature to warn against the possibility of a checked exception being propogated.