Java Programming: From Problem Analysis to Program Design, 4e

1
Java Programming From Problem Analysis to
Program Design, 4e

• Chapter 11
• Handling Exceptions and Events

2
Chapter Objectives

• Learn what an exception is
• See how a try/catch block is used to handle
  exceptions
• Become aware of the hierarchy of exception
  classes
• Learn about checked and unchecked exceptions

3
Chapter Objectives (continued)

• Learn how to handle exceptions within a program
• Discover how to throw and rethrow an exception
• Learn how to handle events in a program

4
Exception

• Definition an occurrence of an undesirable
  situation that can be detected during program
  execution
• Examples
• Division by zero
• Trying to open an input file that does not exist
• An array index that goes out of bounds

5
Handling Exception within a Program

• Can use an if statement to handle an exception
• However, suppose that division by zero occurs in
  more than one place within the same block
• In this case, using if statements may not be the
  most effective way to handle the exception

6
Javas Mechanism of Exception Handling

• When an exception occurs, an object of a
  particular exception class is created
• Java provides a number of exception classes to
  effectively handle certain common exceptions such
  as division by zero, invalid input, and file not
  found
• Division by zero is an arithmetic error and is
  handled by the class ArithmeticException

7
Javas Mechanism of Exception Handling (continued)

• When a division by zero exception occurs, the
  program creates an object of the class
  ArithmeticException
• When a Scanner object is used to input data into
  a program, any invalid input errors are handled
  using the class InputMismatchException
• The class Exception (directly or indirectly) is
  the superclass of all the exception classes in
  Java

8
try/catch/finally Block

• Statements that might generate an exception are
  placed in a try block
• The try block might also contain statements that
  should not be executed if an exception occurs
• The try block is followed by zero or more catch
  blocks
• A catch block specifies the type of exception it
  can catch and contains an exception handler

9
try/catch/finally Block (continued)

• The last catch block may or may not be followed
  by a finally block
• Any code contained in a finally block always
  executes, regardless of whether an exception
  occurs, except when the program exits early from
  a try block by calling the method System.exit
• If a try block has no catch block, then it must
  have the finally block

10
try/catch/finally Block (continued)
11
try/catch/finally Block (continued)

• If no exception is thrown in a try block, all
  catch blocks associated with the try block are
  ignored and program execution resumes after the
  last catch block
• If an exception is thrown in a try block, the
  remaining statements in the try block are ignored
• - The program searches the catch blocks in the
  order in which they appear after the try block
  and looks for an appropriate exception handler

12
try/catch/finally Block (continued)

• If the type of the thrown exception matches the
  parameter type in one of the catch blocks, the
  code of that catch block executes and the
  remaining catch blocks after this catch block are
  ignored
• If there is a finally block after the last catch
  block, the finally block executes regardless of
  whether an exception occurs

13
Order of catch Blocks

• The heading of a catch block specifies the type
  of exception it handles
• A catch block can catch either all exceptions of
  a specific type or all types of exceptions
• A reference variable of a superclass type can
  point to an object of its subclass

14
Order of catch Blocks (continued)

• If in the heading of a catch block you declare an
  exception using the class Exception, then that
  catch block can catch all types of exceptions
  because the class Exception is the superclass of
  all exception classes
• In a sequence of catch blocks following a try
  block, a catch block declaring an exception of a
  subclass type should be placed before catch
  blocks declaring exceptions of a superclass type

15
Java Exception Hierarchy
16
Java Exception Hierarchy (continued)
17
Java Exception Hierarchy (continued)
18
Java Exception Hierarchy (continued)
19
Java Exception Hierarchy (continued)
20
Javas Exception Class

• class Exception
• Subclass of class Throwable
• Superclass of classes designed to handle
  exceptions
• Various types of exceptions
• I/O exceptions
• Number format exceptions
• File not found exceptions
• Array index out of bounds exceptions
• Various exceptions categorized into separate
  classes and contained in various packages

21
The class Exception and its Constructors
22
Java Exception Classes
23
Java Exception Classes (continued)
24
Java Exception Classes (continued)
25
Java Exception Classes (continued)
26
Java Exception Classes (continued)
27
Java Exception Classes (continued)
28
Java Exception Classes (continued)
29
Java Exception Classes (continued)
30
Checked Exceptions

• Definition any exception that can be recognized
  by the compiler
• Examples
• FileNotFoundExceptions

31
Unchecked Exceptions

• Definition exceptions that cannot be recognized
  when the program compiles (must be checked for by
  programmer)
• Examples
• Division by zero
• Array index out of bounds
• Syntax
• ExceptionType1, ExceptionType2, and so on are
  names of exception classes

32
Exceptions Example Code

• public static void exceptionMethod()
• throws InputMismatchException,
• FileNotFoundException
• //statements
• The method exceptionMethod throws exceptions of
  the type InputMismatchException and
  FileNotFoundException

33
The class Exception and the Operator instanceof

• A reference of a superclass type can point to
  objects of its subclass
• You can determine if a reference variable points
  to an object using the operator instanceof
• You can combine catch blocks using this facility

34
The class Exception and the Operator instanceof
try System.out.print("Line 4 Enter the "
"dividend ")
dividend
console.nextInt() System.out.println()
System.out.print("Line 7 Enter the "
"divisor ") divisor
console.nextInt()
System.out.println() quotient dividend
/ divisor System.out.println("Line 11
Quotient " quotient)
catch (Exception eRef) if
(eRef instanceof ArithmeticException)
System.out.println("Line 14 Exception "
eRef.toString())
else if (eRef instanceof InputMismatchException)
System.out.println("Line 16 Exception "
eRef.toString())
35
Rethrowing and Throwing an Exception

• When an exception occurs in a try block, control
  immediately passes to one of the catch blocks
  typically, a catch block does one of the
  following
• Completely handles the exception
• Partially processes the exception in this case,
  the catch block either rethrows the same
  exception or throws another exception for the
  calling environment to handle the exception
• Rethrows the same exception for the calling
  environment to handle the exception

36
Rethrowing and Throwing an Exception (continued)

• Useful when
• Catch block catches exception but is unable to
  handle it
• Catch block decides exception should be handled
  by calling environment
• Allows programmer to provide exception handling
  code in one place
• Syntax
• throw exceptionReference

37
Rethrowing and Throwing an Exception (continued)
import java.util. public class
RethrowExceptionExmp1 static Scanner
console new Scanner(System.in) public
static void main(String args) int
number
try number getNumber()
System.out.println("Line 5 number
" number)
catch (InputMismatchException
imeRef) System.out.println("
Line 7 Exception "
imeRef.toString())
38
Rethrowing and Throwing an Exception (continued)
public static int getNumber()
throws InputMismatchException
int num try
System.out.print("Line 11 Enter an
"integer ") num
console.nextInt()
System.out.println() return num
catch (InputMismatchException
imeRef) throw imeRef

39
The Method printStackTrace

• Used to determine the order in which the methods
  were called and where the exception was handled

40
The Method printStackTrace (continued)
import java.io. public class PrintStackTraceExam
ple1 public static void main(String
args) try
methodA() catch (Exception e)
System.out.println(e.toString
() " caught in
main") e.printStackTrace()

41
The Method printStackTrace (continued)
public static void methodA() throws
Exception methodB()
public static void methodB() throws Exception
methodC() public static void
methodC() throws Exception throw
new Exception("Exception generated "
"in method C")
42
The Method printStackTrace (continued)

• Sample Run
• java.lang.Exception Exception generated in
  method C caught in main
• java.lang.Exception Exception generated in
  method C
• at PrintStackTraceExample1.methodC
• (PrintStackTraceExample1.java30)
• at PrintStackTraceExample1.methodB
• (PrintStackTraceExample1.java25)
• at PrintStackTraceExample1.methodA
• (PrintStackTraceExample1.java20)
• at PrintStackTraceExample1.main
• (PrintStackTraceExample1.java9)

43
Exception-Handling Techniques

• Terminate program
• Output appropriate error message upon termination
• Fix error and continue
• Repeatedly get user input
• Output appropriate error message until valid
  value is entered
• Log error and continue
• Write error messages to file and continue with
  program execution

44
Creating Your Own Exception Classes

• Exception class you define extends class
  Exception or one of its subclasses
• Syntax to throw your own exception object
• throw new ExceptionClassName(messageString)

45
Creating Your Own Exception Classes (continued)
public class MyDivisionByZeroException
extends Exception
public MyDivisionByZeroException()
super("Cannot divide by zero") public
MyDivisionByZeroException(String
strMessage)
super(strMessage)
46
Event Handling

• Action events
• Handled by implementing interface ActionListener
• Window events
• Handled by implementing interface WindowListener
• Mouse events
• Handled by implementing interface MouseListener
• Key events
• Handled by implementing interface KeyListener

47
Event Handling (continued)

• class WindowAdapter
• Implements interface WindowListener with empty
  bodies to methods
• class MouseAdapter
• Implements interface MouseListener with empty
  bodies to methods

48
Registering Listeners

• Registering window listener object to GUI
  component
• Use method addWindowListener
• Window listener object being registered is passed
  as parameter to method addWindowListener
• Registering mouse listener object to GUI
  component
• Use method addMouseListener
• Mouse listener object being registered is passed
  as parameter to method addMouseListener

49
Event Handling (continued)
50
Event Handling (continued)
51
Event Handling (continued)
52
Programming Example Calculator
53
Chapter Summary

• Exception
• Definition
• Handling exceptions within a program
• try/catch/finally block
• Order of catch blocks
• Using try/catch blocks in a program
• The class Exception and the Operator instanceof
• Rethrowing and throwing an exception
• Exception
• Hierarchy
• Classes

54
Chapter Summary (continued)

• Checked and unchecked exceptions
• The method printStackTrace
• Exception-handling techniques
• Terminate program
• Fix error and continue
• Log error and continue
• Creating your own exception classes
• Event handling