Class 12: When Things Go Wrong

Held Wednesday, September 15, 1999

Overview

Today, we will consider exceptions, Java's standard mechanism that permits programmers to indicate, discover, and recover from some errors in programs.

Notes

• I've started grading assignment 1. I hope to have grades and general comments back to you by Friday.
• Are there questions on assignment 2?

Contents

• Problems in Programs
  • Handling Errors
  • Exceptions and Exception Handling
    • Using Methods That Throw Exceptions
    • Optionally-Catchable Exceptions

Summary

• Problems in programs
• Typical error-handling techniques
• Exceptions: Java's primary error-handling mechanism
  • Purpose
  • Using methods that throw exceptions

Problems in Programs

• It's a given that things go wrong in programs.
  • Sometimes, due to mistakes in input or logic, an invalid operation is executed. This may be division by 0, an out-of-bounds array reference, an incorrect input, or a number of other things.
  • Sometimes, due to problems beyond the programmer's control, the system as a whole cannot respond and requested. (The power might go off; a disk might become inoperative, etc.).
  • Sometimes the programmer cannot identify errors in advance (for example, a mail client won't necessarily be immediately able to verify that a username or password are incorrect).
• What do we do about such problems?
  • Only write correct code. Unfortunately, this doesn't work if there is any communication with ``the outside world''.
  • Let the program crash in such cases. Unfortunately, no one likes ot use programs that crash. (Well, I know that Netscape and Microsoft products are exceptions ....)
• Obviously, programmers need to do more. In considering potential resolutions, we'll look at a few examples.
  • In our mail system, we've decided to have a Mailbox object that communicates with the mail server and gives us simple methods for accessing the mail. To create a mailbox for a session, you need an account and password. What should happen in the following if the user enters an incorrect account or password?

        out.print("Enter account: ");
        account = in.readString();
        out.print("Enter password: ");
        password = in.readString();
        Mailbox mail = new Mailbox(account, password);
        MessageInfoList message = mail.getMessages();
        ...
    

  • Yesterday, we wrote a simple program to average grades. What happens if the user enters no grades?

        boolean done = false;
        int count = 0;
        int sum = 0;
        int grade;
        while (!done) {
          out.print("Enter grade: ");
          grade = in.readInt();
          if (grade != DONE) {
            sum = sum + grade;
            count = count + 1;
          }
          else {
            done = true;
          }
        } // while
    

Handling Errors

• One commonly-used technique is to check for errors before any operation and then either skip the operation or recover from the error.
  • In the case of the account/password, we might write

        if (!Mailbox.isvalid(account,password)) {
          out.println("Invalid account or password.");
        }
        else {
          // rest of program
        }
    

  • In the case of the average, we might write

        if (count == 0) {
          out.println("In order to compute an average grade, " +
                      "I must have at least one grade.");
        }
        else {
          out.println("The average grade is " + sum/count);
        }
    

• In the first case, we might even put the test into a loop.

      // Assumption: The empty account with the empty password is
      // not a valid account.
      String account = "";
      String password = "";
      while (!Mailbox.isvalid(account,password)) {
        out.print("Enter account: ");
        account = in.readString();
        out.print("Enter password: ");
        password = in.readString();
      }
      Mailbox mail = new Mailbox(account, password);
  

• We could set up our methods and operations to let us check whether errors happened during operation.
  • In the case of our mailbox, we might write

        Mailbox mail = new Mailbox(account, password);
        if (!mail.isvalid()) {
          out.println("Invalid account.  Exiting ...");
        }
        else {
          // rest of program
        }
    

  • In the case of our average, we might write

       int average = sum / count;
       if (INVALID_MATHEMATICAL_OPERATION) {
         out.println("Could not compute the average.");
       }
       else {
         out.println("The average grade is " + average);
       }
    

• Both techniques are somewhat dangerous, particularly since there is nothing to ensure that programmers use the technique.

Exceptions and Exception Handling

• Java uses a variant of the second 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 create a Mailbox, you may fail because (1) the account/password are incorrect or (2) the server is down'', you would write something like.

    /**
     * Create a new mailbox for a particular account, using the account
     * name and password.  Uses the default mail server, specified in
     * Config.
     *
     * @exception InvalidAccount
     *   If the account or password is invalid.
     * @exception ServerError
     *   If unable to connect to the server.
     */
    public Mailbox(String account, String password)
      throws InvalidAccount, ServerError
    {
      // Code for creating the mailbox.
    } // Mailbox(String, String)
  

• 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 explicilty 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 InvalidAccount, ServerError
  {
    // ...
    Mailbox mail = new Mailbox(account, pasword);
    // ...
  }
  

• To deal 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 requires no coding; it is 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) {
    // ...
    Mailbox mail;
    try {
      mail = new Mailbox(account, password);
    }
    catch (InvalidAccount ia) {
      out.println("Invalid account or password.");
      System.exit(1);
    }
    catch (ServerError se) {
      out.println("Having difficulties connecting to the server.");
      out.println("Try again later.");
      System.exit(2);
    }
    // ...
  } // main
  

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

Optionally-Catchable Exceptions

• What should you do if you want to throw an exception, but you don't care whether the caller catches it or not?
  • Some would argue that this should never happen - all exceptions should be caught.
• You are allowed to throw two things related to exceptions.
  • Errors can not (or should not) be caught. They indicate serious system errors.
  • RuntimeExceptions can be caught, but need not be caught. They seem to be included to accomodate programmers who have not yet bought into (or learned about) Java's exception handling mechanisms.