Exception handling

1
Exception handling

• Dealing with lifes little surprises

2
Program correctness

• The term program correctness refers to a
  programs working as advertised that is, it
  produces correct results for valid inputs
• A related concept is program reliability this is
  a measure of how well a program performs under a
  variety of conditions (including invalid inputs)
• A program can be correct, but not reliable
• A program can be reliable, but not correct
• Our goal is to produce programs with both these
  qualities

3
Ensuring reliability

• We do our best to ensure program correctness
  through a rigorous testing and debugging process
• To ensure reliability, we must anticipate
  conditions that could cause problems, and try to
  deal with them before the problems occur
• In Java, we have exception handling, a powerful
  tool for ensuring program reliability

4
Exceptions

• An error condition that occurs during program
  runtime is called an exception
• Exceptions are represented by exception objects,
  which are generated (thrown) in response to error
  conditions
• Java includes a rich set of routines for dealing
  with such circumstances this is known as
  exception handling

5
Catching exceptions try/catch block

• Consists of try block followed by one or more
  catch blocks
• try block encloses code that might throw an
  exception
• catch block(s) deal with any exception(s) thrown

6
Syntax for try/catch block
try // code that may throw an exception
catch (ExceptionType parameterName) // code
that handles an exception thrown // in the try
block
7
Catching Exceptions

• Statements in the try block are executed in
  sequence.
• If no error occurs then no exception is thrown,
  all statements in the try block are executed and
  the catch block(s) will be skipped

8
Catching Exceptions

• When one of the statements throws an exception,
  control is passed to the matching catch block and
  statements inside the catch block are executed
• Provided the catch block does not halt the
  program or return from the method, program
  execution continues at the first statement
  following the catch block
• If more than one exception is possible, multiple
  catch blocks can be written

9
Example
int value // number to be supplied by
user String input // value read from
keyboard Scanner kb new Scanner
(System.in) System.out.print (Enter a number
) input kb.nextLine() try value
Integer.parseInt() catch
(InputMismatchException e) System.out.println
(input is not valid.\n Please enter
digits only.)
10
Exception classes

• The previous example included an instance of
  InputMismatchException, one of many Exception
  classes defined in the Java API
• Examples of exceptions you may have encountered
  as runtime errors include
• IOException
• NoSuchMethodException
• ArrayIndexOutOfBoundsException
• NullPointerException

11
Exception classes

• All exception classes have the following
  characteristics
• a constructor that takes a single String argument
  (often just the name of the exception, in quotes)
• a getMessage() method that can recover the String
  with which the exception object was constructed
• Generally speaking, the String briefly describes
  the type of error encountered

12
The catch blocks parameter

• The syntax of the catch block is very similar to
  that of a method definition
• catch (ExceptionType parameterName)
• // code to execute if exception was thrown
• The catch blocks parameter does 2 things
• specifies the type of exception being handled
• provides a name for the thrown object, so that
  the objects method(s) can be called

13
Multiple catch blocks

• A single block of code may throw multiple
  exceptions
• For example, consider the code fragment below
• String input kb.nextLine()
• int x Integer.parseInt(input) // could throw
• // InputMismatchException
• arrayx x // could throw
• // ArrayIndexOutOfBoundsException
• When multiple types of exception objects may be
  thrown, the try block should be followed by
  multiple catch blocks
• In any one execution of a try block, only one
  exception can be thrown, since execution of the
  try block stops if such an error occurs

14
Multiple catch blocks

• When multiple catch blocks are used, the order of
  the blocks sometimes matters
• When an exception is thrown, the catch blocks are
  examined in order, and the first that will handle
  the error is executed
• The catch blocks that handle the least specific
  exception types should be placed last, so the
  that a more specific exception can be caught by
  the most appropriate catch block
• Failure to place catch blocks in the correct
  order (specific to general) results in a compiler
  warning

15
The Exception Class

• The Java APIs default java.lang package contains
  the Exception class, from which more specific
  types of exceptions may be derived
• All of the exception classes defined in the Java
  API inherit their common characteristics from the
  Exception class

16
Throwing exceptions

• We can define our own error conditions, and set
  up mechanisms to deal with them, using our own
  Exception objects
• The code on the next slide, for instance, expands
  the previous numeric input example by imposing
  upper and lower limits on the int value that can
  be entered

17
Example
System.out.print (Enter a number between 1 and
100 ) input kb.nextLine() try value
Integer.parseInt() if (value lt 1 value gt
100) throw new Exception (value out of
range) catch (InputMismatchException e)
System.out.println (input is not valid.\n
Please enter digits only.) catch
(Exception e) System.out.println
(e.getMessage())
18
An exception-controlled loop

• The previous example handled the case of bad
  numeric input by printing an error message
  appropriate to the problem (not a number vs. an
  invalid number)
• A more robust program would go one step further
  get new input to replace the bad
• An exception-controlled loop like the one shown
  on the next slide takes this extra step

19
Example assumes existence of instance variable
kb and constants UPPER and LOWER
public int getNumData (String prompt) String
inputStr int num while (true)
inputStr kb.nextLine() try
num Integer.parseInt(inputStr)
if (num lt LOWER num gt UPPER)
throw new Exception("Input out of bounds")
return num // input okay so return the
value exit, ending loop catch
(InputMismatchException e)
System.out.println(inputStr " is invalid\n"
"Please enter digits only") catch
(Exception e) System.out.println(e.getMessage()
) // end catch block // end while
loop // end method
20
Checked unchecked exceptions

• There are two general types of exceptions that
  may occur within programs
• checked exceptions are those that must be
  accounted for or the program wont compile
• unchecked exceptions are those that the compiler
  doesnt account for hence the name
• Most of the exceptions we have discussed so far
  have been unchecked exceptions

21
Not catching exceptions

• As stated on the previous slide, there are some
  types of exceptions that we must handle in order
  for our programs to compile
• There are times when we may not wish to catch
  exceptions in our code, but are forced to deal
  with them because they are checked
• In such a situation, a throws clause can be used
  instead of a try/catch block

22
Example

• Suppose you have a method that appears to you to
  be coded correctly, but the compiler keeps coming
  back with an error message like the following
• unreported exception java.lang.InterruptedExceptio
  n must be caught or declared to be thrown
• This message results from an attempt to compile a
  method with a checked exception that has not been
  handled

23
Example
The class shown below contains a main method that
would produce the compiler message shown on the
previous slide public class ThreadTest public
static void main(String args)
Thread.sleep(100) System.out.println
("2") One way to take care of the
exception and get rid of the error message is
shown on the following slide
24
Example
public class ThreadTest public static void
main(String args) throws
InterruptedException System.out.println
("1") Thread.sleep(100)
System.out.println ("2") The throws
clause, which is part of the method heading,
simply indicates that we acknowledge that an
exception might occur, and that it will be
handled elsewhere. This is the default behavior
with unchecked exceptions we only have to add a
throws clause if our code could throw a checked
exception.
25
Defining exception classes

• We have already seen that an exception object can
  be instantiated within a try block, and that a
  corresponding catch block can be written to deal
  with the object if thrown
• In examples so far, all of the objects have been
  Exception objects but they could be of any
  exception type
• We can also define new exception classes

26
Defining exception classes

• You can define your own exception classes to
  cover cases not defined by the standard exception
  classes
• You can take advantage of Javas inheritance
  mechanisms to simplify the process

27
Inheritance basics

• A parent class (aka superclass) is a class with
  variables and methods that can be passed on to
  classes derived from it
• A child class (aka subclass or derived class)
  automatically contains all inherited members, and
  can add more members or modify the inherited
  members as necessary

28
Inheriting from Exception

• As previously mentioned, the Exception class has
  a constructor that takes a String argument, and a
  getMessage method that returns the String
• Child classes derived from Exception can be
  defined very simply, by defining a set of
  constructors that refer back to the inherited
  constructors see next slide

29
Example

• public class MyNewException extends Exception
• public MyNewException ()
• super (I take exception to that!)
• public MyNewException (String msg)
• super (msg)
• Notes
• the keyword extends indicates an inheritance
  relationship with the named superclass
• the keyword super is used to call the
  superclasss constructor

30
Example

• To test the new exception class, well create two
  more classes
• The Question class method askQuestion contains a
  line of code that instructs the program to throw
  an exception under certain circumstances
• The QuestionUser classs main method calls
  askQuestion and contains the code to handle the
  exception if its thrown

31
Question class
import java.util. public class Question
public void askQuestion () throws MyNewException
Scanner kb new Scanner(System.in)
System.out.print ("Who is the fairest one of
all? ") String answer kb.nextLine()
if (!answer.equalsIgnoreCase("Cate"))
throw new MyNewException() else
System.out.println("You are so
right!")
32
QuestionUser class
public class QuestionUser public static
void main (String args) Question q
new Question() try
q.askQuestion() catch (MyNewException
e) System.out.println(e.getMessage()
)
33
Sample output
Who is the fairest one of all? cate You are so
right! Who is the fairest one of all? Snow
White I take exception to that!
34
OK, but seriously

• When possible, you should catch exceptions
• Checked exceptions must be caught the compiler
  will tell you about these. You can choose to
  handle them yourself, or you can put a throws
  clause in your method header
• Unchecked exceptions (also known as runtime
  exceptions), such as invalid input, should be
  handled using try/catch blocks in your code
  this will make your code more robust

35
When to throw exceptions

• The example we looked at earlier was a silly one,
  and could have been handled much more smoothly
  (and in a single class) with a simple if/else
  statement
• In other words, this is an example of when NOT to
  throw an exception

36
When to throw exceptions

• To quote the text
• Reserve throw statements for situations in which
  the way the exceptional condition is handled
  depends on how and where the method is used. If
  the way the exceptional condition is handled
  depends on how and where the method is invoked,
  then the best thing to do is to let the
  programmer who invokes the method handle the
  exception. In all other situations, it is
  preferable to avoid throwing exceptions.
• Read the example on page 556 to see a serious
  example of exception throwing