Class 16: Exceptions (1)

Held: Wednesday, 21 September 2005

Summary: Today we consider exceptions, Java's primary technique for reporting and recovering from problems.

Related Pages:

• EBoard.
• Lab on exceptions.
• Reading on exceptions.

Assignments

• Reread When Things Go Wrong: Exceptions in Java in Espresso.

Due

• Homework 2.

Notes:

• Norman Perlmutter speaks today at 4:30 on Bi-cycles and Tri-cycles. Extra credit for attending.
• Tomorrow's convocation slot has a concert by Gene Gaub. Extra credit for attending.
• Grading still not done. Sorry. Should be done by Friday.
• Friday's reading not available until tonight.
• Take-home exam 1 to be distributed on Friday.

Overview:

• Exceptions: Java's Primary Error-Handling Technique.
• Lab.

Exceptions and Exception Handling

• Java uses a variant of the error signaling technique through a concept known as exceptions. The designers of Java decided that there should be a clear standard for handling erroneous or dangerous conditions.
• Java is fairly strict about those exceptions because the designers observed that most programmers
  • assume that things will generally go right;
  • ignore problems when developing developing solutions with the expectation that I'll fix it once I get the 'real' stuff working; and
  • never get back to worrying about errors.
• In Java, possible problems are called exceptions, presumably because they are exceptions to the rule.
• Exceptions are associated with methods. Each method that may lead to errors lists the possible errors (exceptions) that may occur. Any code that uses that method must indicate what to do when the errors occur.
• For example, to say When you try to read an integer you may fail because the user enters a non-number, you might write something like:

    /**
     * Read an integer.
     *
     * @exception NumberFormatException
     *   if the user enters something other than an integer
     */
    public int readInt()
      throws NumberFormatException
    // ...
  

• When something goes wrong, a method throws an exception.

Using Methods That Throw Exceptions

• Whenever you call a method that may throw an exception, you need to handle it. You can
  • Deal explicitly with the error.
  • Pass the error on the method that called your method.
• The second is easier, but less useful. To pass an exception on, you need to declare that your method throws the exception.
• For example,

  public static void main(String[] args) 
    throws NumberFormatException
  {
    // ...
    int row = in.readInt();
    // ...
  }
  

• To deal explicitly with exceptions, you need to do a few things.
  • Determine the possible errors that can occur and decide how you want to handle them. (This step requires no coding; instead, it requires careful analysis of the problem.)
  • Note that you understand that errors can occur by placing the potentially exceptional code in a try clause.
  • For each possible exception, list what you want to do to recover from the error in a catch clause.
• In Java,

    try {
      // stuff that may have problems
    }
    catch (ExceptionClass e1) {
      // Handle one type of exception
    }
    catch (AnotherExceptionClass e2) {
      // Handle another type of exception
    }
    finally {
      // Clean-up code that is always executed.
    }
  

• For example,

  public static void main(String[] args) 
    throws Exception
  {
    // ...
    int row = -1;
    while (row < 0) {
      try {
        row = in.readInt();
      }
      catch (NumerFormatException e) {
        out.println("Not a number");
      }
    } // while
    // ...
  } // main
  

• Java's standard libraries include a number of types of exceptions, including java.io.IOException and java.lang.NumberFormatException.

Lab

• Attempt the exceptions lab.
• Please work in pairs.