Download ch12

Chapter 12: Handling Exceptions and
Events
Java Programming:
Program Design Including Data Structures
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
Java Programming: Program Design Including Data Structures
2
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
Java Programming: Program Design Including Data Structures
3
Exception
 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
Java Programming: Program Design Including Data Structures
4
Handling Exceptions 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
Java Programming: Program Design Including Data Structures
5
Java’s 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
handle certain common exceptions, such as:
 Division by zero
 Invalid input
 File not found
Java Programming: Program Design Including Data Structures
6
Java’s Mechanism of Exception
Handling (continued)
 Division by zero is:
 An arithmetic error
 Handled by the class ArithmeticException
 When a division by zero exception occurs, the
program creates an object of the class
ArithmeticException
Java Programming: Program Design Including Data Structures
7
Java’s Mechanism of Exception
Handling (continued)
 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
Java Programming: Program Design Including Data Structures
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
 Is followed by zero or more catch blocks
 A catch block:
 Specifies the type of exception it can catch
 Contains an exception handler
Java Programming: Program Design Including Data Structures
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
Java Programming: Program Design Including Data Structures
10
try/catch/finally Block
(continued)
Java Programming: Program Design Including Data Structures
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
Java Programming: Program Design Including Data Structures
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 are ignored
 If there is a finally block after the last catch
block, the finally block executes regardless of
whether an exception occurs
Java Programming: Program Design Including Data Structures
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
Java Programming: Program Design Including Data Structures
14
Order of catch Blocks
(continued)
 If you declare an exception using the class
Exception in the heading of a catch block, 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 that declares an exception of a
subclass type should be placed before catch blocks
that declare exceptions of a superclass type
Java Programming: Program Design Including Data Structures
15
Order of catch Blocks
(continued)
Java Programming: Program Design Including Data Structures
16
Order of catch Blocks
(continued)
Java Programming: Program Design Including Data Structures
17
Order of catch Blocks
(continued)
Java Programming: Program Design Including Data Structures
18
Order of catch Blocks
(continued)
Java Programming: Program Design Including Data Structures
19
Order of catch Blocks
(continued)
Java Programming: Program Design Including Data Structures
20
Java’s 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
Java Programming: Program Design Including Data Structures
21
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
22
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
23
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
24
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
25
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
26
Java’s Exception Class
(continued)
Java Programming: Program Design Including Data Structures
27
Checked Exceptions
 Any exception that can be analyzed by the
compiler
 Example:
 FileNotFoundExceptions
Java Programming: Program Design Including Data Structures
28
Unchecked Exceptions
 Exceptions that cannot be analyzed when the
program compiles (programmer must be check)
 Examples:
 Division by zero
 Array index out of bounds
 Syntax:
throws ExceptionType1,
ExceptionType2,...
ExceptionType1, ExceptionType2, and so on
are names of exception classes
Java Programming: Program Design Including Data Structures
29
Exceptions Example Code
public static void exceptionMethod()
throws InputMismatchException,
FileNotFoundException
{
//statements
}
 The method exceptionMethod throws
exceptions of the type
InputMismatchException and
FileNotFoundException
Java Programming: Program Design Including Data Structures
30
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
Java Programming: Program Design Including Data Structures
31
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);
}
Java Programming: Program Design Including Data Structures
32
The class Exception and
the Operator instanceof
(continued)
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());
}
Java Programming: Program Design Including Data Structures
33
Rethrowing and Throwing an
Exception
 When an exception occurs in a try block, control
immediately passes to one of the catch blocks
 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
Java Programming: Program Design Including Data Structures
34
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;
Java Programming: Program Design Including Data Structures
35
Rethrowing and Throwing an
Exception
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());
}
}
} Java Programming: Program Design Including Data Structures
36
Rethrowing and Throwing an
Exception
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;
}
}
Java Programming:
Program Design Including Data Structures
37
The Method
printStackTrace
 Determines the order in which the methods were
called and where the exception was handled
Java Programming: Program Design Including Data Structures
38
The Method
printStackTrace
import java.io.*;
public class PrintStackTraceExample1
{
public static void main(String[] args)
{
try
{
methodA();
}
catch (Exception e)
{
System.out.println(e.toString()
+ " caught in main");
e.printStackTrace();
}
}
Java Programming: Program Design Including Data Structures
39
The Method
printStackTrace
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");
}
}
Java Programming: Program Design Including Data Structures
40
The Method
printStackTrace
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.java:31)
at PrintStackTraceExample1.methodB
(PrintStackTraceExample1.java:26)
at PrintStackTraceExample1.methodA
(PrintStackTraceExample1.java:22)
at PrintStackTraceExample1.main
(PrintStackTraceExample1.java:11)
Java Programming: Program Design Including Data Structures
41
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
Java Programming: Program Design Including Data Structures
42
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);
Java Programming: Program Design Including Data Structures
43
Creating Your Own Exception
Classes
public class MyDivisionByZeroException
extends Exception
{
public MyDivisionByZeroException()
{
super("Cannot divide by zero");
}
public MyDivisionByZeroException(String
strMessage)
{
super(strMessage);
}
}
Java Programming: Program Design Including Data Structures
44
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
Java Programming: Program Design Including Data Structures
45
Event Handling (continued)
 class WindowAdapter:
 Implements interface WindowListener
with empty bodies to methods
 class MouseAdapter:
 Implements interface MouseListener
with empty bodies to methods
Java Programming: Program Design Including Data Structures
46
Registering Listeners
 To register window listener object to GUI component:
 Use method addWindowListener
 Window listener object being registered is passed as
parameter to method addWindowListener
 To register mouse listener object to GUI component:
 Use method addMouseListener
 Mouse listener object being registered is passed as
parameter to method addMouseListener
Java Programming: Program Design Including Data Structures
47
Registering Listeners (continued)
Java Programming: Program Design Including Data Structures
48
Registering Listeners (continued)
Java Programming: Program Design Including Data Structures
49
Registering Listeners (continued)
Java Programming: Program Design Including Data Structures
50
Programming Example:
Calculator
Java Programming: Program Design Including Data Structures
51
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
Java Programming: Program Design Including Data Structures
52
Chapter Summary (continued)
 Exception
 Hierarchy
 Classes
 Checked and unchecked exceptions
 The method printStackTrace
Java Programming: Program Design Including Data Structures
53
Chapter Summary (continued)
 Exception handling techniques:
 Terminate program
 Fix error and continue
 Log error and continue
 Creating your own exception classes
 Event handling
Java Programming: Program Design Including Data Structures
54