Outline of Class 10: Error Handling

Held: Tuesday, February 3, 1998

Administrivia

• The exotic programming languages discussion group meets at 4:15 today. Come and learn about the wonders of Haskell.
• This Thursday at 4:15, selected math and CS faculty will be discussing summer research opportunities. Come hear how you can get both money and credit while participating in interesting projects.
• This Thursday at 7:30, Mike Jipping from Hope college will be speaking on threads in Java. His talk is based in part on work done with undergraduates as part of Hope's REU program.
• There have been a number of questions about assignment 2. We'll spend a little while today trying to resolve some of those questions.
• We have now permanently moved to the MathLAN classroom.
• Make sure to read chapter 2 of Bailey for tomorrow.
• Today we'll do lab 4.

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, or a number of other things.
  • Sometimes, due to problems beyond the programmer's control, the system as a whole cannot respond and requested.
• What do we do about such problems?
  • Only write correct code.
  • Let the program crash in such cases.
  • Try to predict the cases, and prefix any statement that may have problems with a test and recovery.
  • Wait for the system to tell us about the problem, and react to that notification.

Exceptions

• Java supports a concept known as exceptions. Basically, Java admits that things can go wrong, and programmers should handle those things.
• 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"
  • 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 (excxeptions) that may occur.
• When something goes wrong, a method throws an exception.
• Whenever you call a method that may throw an exception, you need to handle it. You can
  • Deal with the error.
  • Pass the error on the your calling method.
• The second is easier, but less useful. To pass an exception on, you need to declare that your method throws the exception, as in

  public int MyCoolMethod() 
    throws IOException, NumberFormatException
  {
    ...
  } // MyCoolMethod()
  

• 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.
  }
  

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

Throwing Exceptions

• At times, you'll want to throw exceptions from a method because your method has encountered problems.
• In these cases, you'll need to
  • Determine which kind of exception to throw (sometimes an existing kind of exception; sometimes a new kind).
  • Define any new types of exceptions you'll need.
  • Determine an appropriate error message.
  • Create and throw the the exception.
  • Indicate that your method throws
• You can create and throw an exception with
  throw new MyException(message);
• You indicate that your method may throw an exception with a throws clause, as in

  public static void teach()
    throws ClassOverException
  {
    ...
  } // teach
  

• If you need to define your own exception, create a separate class for that exception and have it extend Exception.

Lab

Today, we'll work on a lab in which you'll experiment with exceptions by adding exception handling to your calculators.