1

Chapter 15 – Exception Handling

Outline
15.1 Introduction
15.2 Exception-Handling Overview
15.3 Exception-Handling Example: Divide by Zero
15.4 Java Exception Hierarchy
15.5 Rethrowing an Exception
15.6 finally Clause
15.7 Stack Unwinding
15.8 printStackTrace, getStackTrace and getMessage
15.9 Chained Exceptions
15.10 Declaring New Exception Types
15.11 Constructors and Exception Handling

 2003 Prentice Hall, Inc. All rights reserved.

 2

15.1 Introduction

• Exception handling
– Exception
• Indication of problem during execution
– E.g., divide by zero
– Chained exceptions

 2003 Prentice Hall, Inc. All rights reserved.

 3

15.2 Exception-Handling Overview

• Uses of exception handling

– Process exceptions from program components
– Handle exceptions in a uniform manner in large projects
– Remove error-handling code from “main line” of execution
• A method detects an error and throws an exception
– Exception handler processes the error
– Uncaught exceptions yield adverse effects
• Might terminate program execution

 2003 Prentice Hall, Inc. All rights reserved.

 4

15.2 Exception-Handling Overview

• Code that could generate errors put in try blocks

– Code for error handling enclosed in a catch clause
– The finally clause always executes
• Termination model of exception handling
– The block in which the exception occurs expires
• throws clause specifies exceptions method
throws

 2003 Prentice Hall, Inc. All rights reserved.

 5
15.3 Exception-Handling Example: Divide by
Zero
• Common programming mistake
• Throws ArithmeticException

 2003 Prentice Hall, Inc. All rights reserved.

1 // Fig. 15.1: DivideByZeroTest.java Outline
2 // An exception-handling example that checks for divide-by-zero.
3 import java.awt.*;
4 import java.awt.event.*; DivideByZeroTes
5 import javax.swing.*;
6
t.java
7 public class DivideByZeroTest extends JFrame
8 implements ActionListener {
9
10 private JTextField inputField1, inputField2, outputField;
11 private int number1, number2, result;
12
13 // set up GUI
14 public DivideByZeroTest()
15 {
16 super( "Demonstrating Exceptions" );
17
18 // get content pane and set its layout
19 Container container = getContentPane();
20 container.setLayout( new GridLayout( 3, 2 ) );
21
22 // set up label and inputField1
23 container.add(
24 new JLabel( "Enter numerator ", SwingConstants.RIGHT ) );
25 inputField1 = new JTextField();
26 container.add( inputField1 );

 2003 Prentice Hall, Inc.

All rights reserved.
27 Outline
28 // set up label and inputField2; register listener
29 container.add( new JLabel( "Enter denominator and press Enter ",
30 SwingConstants.RIGHT ) ); DivideByZeroTes
31 inputField2 = new JTextField();
32 container.add( inputField2 );
t.java
33 inputField2.addActionListener( this );
34 Line 51
35 // set up label and outputField
36 container.add( new JLabel( "RESULT ", SwingConstants.RIGHT ) );
Lines 52-53
37 outputField = new JTextField();
38 container.add( outputField );
39
40 setSize( 425, 100 );
41 setVisible( true );
42
43 } // end DivideByZeroTest constructor
44
45 // process GUI events The try block
46 public void actionPerformed( ActionEvent event )
47 {
48 outputField.setText( "" ); // clear outputField Read integers from
49 JTextFields
50 // read two numbers and calculate quotient
51 try {
52 number1 = Integer.parseInt( inputField1.getText() );
53 number2 = Integer.parseInt( inputField2.getText() );

 2003 Prentice Hall, Inc.

All rights reserved.
54
Method quotientOutline
55 result = quotient( number1, number2 );
56 outputField.setText( String.valueOf( result ) );
attempts division
57 } DivideByZeroTes
58
59
t.java
// process improperly formatted input Catch
60 catch ( NumberFormatException numberFormatException ) {
61 JOptionPane.showMessageDialog( this,
NumberFormatException
Line 55
62 "You must enter two integers", "Invalid Number Format",
63 JOptionPane.ERROR_MESSAGE );
Line 60
64 }
65
66 // process attempts to divide by zero Line 67
Catch
67 catch ( ArithmeticException arithmeticException ) {
ArithmeticException
68 JOptionPane.showMessageDialog( this, Line 77
69 arithmeticException.toString(), "Arithmetic Exception",
70 JOptionPane.ERROR_MESSAGE );
71 }
72
73 } // end method actionPerformed
74
75 // demonstrates throwing an exception when a divide-by-zero occurs
76 public int quotient( int numerator, int denominator )
77 throws ArithmeticException
Method quotient throws
78 { ArithmeticException
79 return numerator / denominator;
80 }

 2003 Prentice Hall, Inc.

All rights reserved.
81 Outline
82 public static void main( String args[] )
83 {
84 DivideByZeroTest application = new DivideByZeroTest(); DivideByZeroTes
85 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
86 }
t.java
87
88 } // end class DivideByZeroTest

 2003 Prentice Hall, Inc.

All rights reserved.
 10

15.4 Java Exception Hierarchy

• Superclass Throwable
– Subclass Exception
• Exceptional situations
• Should be caught by program
– Subclass Error
• Typically not caught by program
• Checked exceptions
– Catch or declare
• Unchecked exceptions

 2003 Prentice Hall, Inc. All rights reserved.

 Fig. 15.2 Inheritance hierarchy for class 11

Throwable

Throwable

Exception Error

RuntimeException IOException AWTError ThreadDeath OutOfMemoryError

 2003 Prentice Hall, Inc. All rights reserved.

 12

15.5 Rethrowing an Exception

• Rethrow exception if catch cannot handle it

 2003 Prentice Hall, Inc. All rights reserved.

 13

15.6 finally Clause

• Resource leak
– Caused when resources are not released by a program
• The finally block
– Appears after catch blocks
– Always executes
– Use to release resources

 2003 Prentice Hall, Inc. All rights reserved.

1 // Fig. 15.3: UsingExceptions.java Outline
2 // Demonstration of the try-catch-finally exception handling mechanism.
3 public class UsingExceptions {
4 UsingExceptions
5 public static void main( String args[] )
6 {
.java
7 try {
8 throwException(); // call method throwException
9 }
10
11 // catch Exceptions thrown by method throwException
12 catch ( Exception exception ) {
13 System.err.println( "Exception handled in main" );
14 }
15
16 doesNotThrowException();
17 }
18
19 // demonstrate try/catch/finally
20 public static void throwException() throws Exception
21 {
22 // throw an exception and immediately catch it
23 try {
24 System.out.println( "Method throwException" );
25 throw new Exception(); // generate exception
26 }

 2003 Prentice Hall, Inc.

All rights reserved.
27 Outline
28 // catch exception thrown in try block
29 catch ( Exception exception ) {
30 System.err.println( UsingExceptions
31 "Exception handled in method throwException" );
32 throw exception; // rethrow for further processing Rethrow .java
Exception
33
34 // any code here would not be reached Line 32
35 }
36
Lines 38-40
37 // this block executes regardless of what occurs in try/catch
38 finally {
The finally block executes,
39 System.err.println( "Finally executed in throwException" ); even though Exception thrown
40 }
41
42 // any code here would not be reached
43
44 } // end method throwException
45
46 // demonstrate finally when no exception occurs
47 public static void doesNotThrowException()
48 {
49 // try block does not throw an exception
50 try {
51 System.out.println( "Method doesNotThrowException" );
52 }

 2003 Prentice Hall, Inc.

All rights reserved.
53 Outline
54 // catch does not execute, because no exception thrown
55 catch ( Exception exception ) {
56 System.err.println( exception ); UsingExceptions
57 }
58
.java
59 // this clause executes regardless of what occurs in try/catch
The 60-63 block
finally
Lines
60 finally {
61 System.err.println(
always executes
62 "Finally executed in doesNotThrowException" );
63 }
64
65 System.out.println( "End of method doesNotThrowException" );
66
67 } // end method doesNotThrowException
68
69 } // end class UsingExceptions
Method throwException
Exception handled in method throwException
Finally executed in throwException
Exception handled in main
Method doesNotThrowException
Finally executed in doesNotThrowException
End of method doesNotThrowException

 2003 Prentice Hall, Inc.

All rights reserved.
 17

15.7 Stack Unwinding

• Exception not caught in scope

– Method terminates
– Stack unwinding occurs
– Another attempt to catch exception

 2003 Prentice Hall, Inc. All rights reserved.

1 // Fig. 15.4: UsingExceptions.java Outline
2 // Demonstration of stack unwinding.
3 public class UsingExceptions {
4 UsingExceptions
5 public static void main( String args[] )
6 {
.java
7 // call throwException to demonstrate stack unwinding
8 try { Line 9
Call method
9 throwException();
10 } throwException
Line 13
11
12 // catch exception thrown in throwException Catch Exception from
13 catch ( Exception exception ) { Line 19
14 System.err.println( "Exception handled in main" );
method throwExcetion
15 } Line 24
16 }
17
18 // throwException throws exception that is not caught in this method
19 public static void throwException() throws Exception
20 {
21 // throw an exception and catch it in main
Method declares a
22 try { throws clause
23 System.out.println( "Method throwException" );
24 throw new Exception(); // generate exception
25 } Throw an Exception
26

 2003 Prentice Hall, Inc.

All rights reserved.
27 // catch is incorrect type, so Exception is not caught Outline
28 catch ( RuntimeException runtimeException ) {
29 System.err.println(
30 "Exception handled in method throwException" ); UsingExceptions
31 }
32
.java
33 // finally clause always executes
34 finally {
35 System.err.println( "Finally is always executed" );
36 }
37
38 } // end method throwException
39
40 } // end class UsingExceptions

 Method throwException
Finally is always executed
Exception handled in main

 2003 Prentice Hall, Inc.

All rights reserved.
 20
15.8 printStackTrace, getStackTrace
and getMessage
• Throwable class
– Method printStackTrace
• Prints method call stack
– Method getStackTrace
• Obtains stack-trace information
– Method getMessage
• Returns descriptive string

 2003 Prentice Hall, Inc. All rights reserved.

1 // Fig. 15.5: UsingExceptions.java Outline
2 // Demonstrating getMessage and printStackTrace from class Exception.
3 public class UsingExceptions {
4 UsingExceptions
5 public static void main( String args[] )
6 {
.java
7 try {
8 method1(); // call method1 Line 8
Call method1
9 }
10
Lines 13-14
11 // catch Exceptions thrown from method1
12 catch ( Exception exception ) { Print information generated
13 System.err.println( exception.getMessage() + "\n" ); Lines 25-26
by getMessage and
14 exception.printStackTrace(); printStackTrace
15
16 // obtain the stack-trace information
17 StackTraceElement[] traceElements = exception.getStackTrace();
18
19 System.out.println( "\nStack trace from getStackTrace:" );
20 System.out.println( "Class\t\tFile\t\t\tLine\tMethod" ); Print StackTraceElements
21
22 // loop through traceElements to get exception description
23 for ( int i = 0; i < traceElements.length; i++ ) {
24 StackTraceElement currentElement = traceElements[ i ];
25 System.out.print( currentElement.getClassName() + "\t" );
26 System.out.print( currentElement.getFileName() + "\t" );

 2003 Prentice Hall, Inc.

All rights reserved.
27 System.out.print( currentElement.getLineNumber() + "\t" ); Outline
28 System.out.print( currentElement.getMethodName() + "\n" );
29
30 } // end for statement UsingExceptions
31
32 } // end catch
.java
Print StackTraceElements
33
34 } // end method main Lines 27-28
35
36 // call method2; throw exceptions back to main
method1 Line 37 a
declares
37 public static void method1() throws Exception
38 { throw clause
39 method2(); Line 39
Call method2
40 }
41 Line 43
42 // call method3; throw exceptions back to method1
43 public static void method2() throws Exception
method2 declares a
44 { throwLine 45
clause
45 method3(); Call method3
46 } Line 49
47
48 // throw Exception back to method2
method3Line 51 a
declares
49 public static void method3() throws Exception
50 { throw clause
51 throw new Exception( "Exception thrown in method3" );
52 } Throw an
Exception that
propagates back to
main
 2003 Prentice Hall, Inc.
All rights reserved.
53 Outline
54 } // end class Using Exceptions

Exception thrown in method3

  UsingExceptions
java.lang.Exception: Exception thrown in method3 .java
at UsingExceptions.method3(UsingExceptions.java:51)
at UsingExceptions.method2(UsingExceptions.java:45)
at UsingExceptions.method1(UsingExceptions.java:39)
at UsingExceptions.main(UsingExceptions.java:8)
 
Stack trace from getStackTrace:
Class File Line Method
UsingExceptions UsingExceptions.java 51 method3
UsingExceptions UsingExceptions.java 45 method2
UsingExceptions UsingExceptions.java 39 method1
UsingExceptions UsingExceptions.java 8 main

 2003 Prentice Hall, Inc.

All rights reserved.
 24

15.9 Chained Exceptions

• Wraps existing exception in a new exception

– enables exception to maintain complete stack-trace

 2003 Prentice Hall, Inc. All rights reserved.

1 // Fig. 15.6: UsingChainedExceptions.java Outline
2 // Demonstrating chained exceptions.
3 public class UsingChainedExceptions {
4 UsingChainedExc
5 public static void main( String args[] )
6 {
eptions.java
7 try {
8 method1(); // call method1 Line 8
Call method1
9 }
10
Lines 12-14
11 // catch Exceptions thrown from method1
Catch Exception
12 catch ( Exception exception ) {
13 exception.printStackTrace(); and printLine
stack18trace
14 }
15 } Line 21
16
17 // call method2; throw exceptions back to main
18 public static void method1() throws Exception
method1 declares
Line 26 a
19 { throw clause
20 try {
21 method2(); // call method2 Call method2
22 }
23 An existing Exception
24 // catch Exception thrown from method2
is chained to another
25 catch ( Exception exception ) {
26 throw new Exception( "Exception thrown in method1", exception );

 2003 Prentice Hall, Inc.

All rights reserved.
27 } Outline
28 }
29
30 // call method3; throw exceptions back to method1 UsingChainedExc
31 public static void method2() throws Exception method2 declares a
32 { throweptions.java
clause
33 try {
34 method3(); // call method3 Line 31
Call method3
35 }
36
LineException
An existing 34
37 // catch Exception thrown from method3
38 catch ( Exception exception ) { is chained to another
39 throw new Exception( "Exception thrown in method2", exception ); Line 39
40 }
41 } Line 46
42
Throw a new
43 // throw Exception back to method2
44 public static void method3() throws Exception
Exception
45 {
46 throw new Exception( "Exception thrown in method3" );
47 }
48
49 } // end class Using Exceptions

 2003 Prentice Hall, Inc.

All rights reserved.
java.lang.Exception: Exception thrown in method1 Outline
at UsingChainedExceptions.method1(UsingChainedExceptions.java:26)
at UsingChainedExceptions.main(UsingChainedExceptions.java:8)
Caused by: java.lang.Exception: Exception thrown in method2 UsingChainedExc
at UsingChainedExceptions.method2(UsingChainedExceptions.java:39)
at UsingChainedExceptions.method1(UsingChainedExceptions.java:21)
eptions.java
... 1 more
Caused by: java.lang.Exception: Exception thrown in method3
at UsingChainedExceptions.method3(UsingChainedExceptions.java:46)
at UsingChainedExceptions.method2(UsingChainedExceptions.java:34)
... 2 more

 2003 Prentice Hall, Inc.

All rights reserved.
 28

15.10 Declaring New Exception Types

• Extend existing exception class

 2003 Prentice Hall, Inc. All rights reserved.

 29

15.11 Constructors and Exception Handling

• Throw exception if constructor causes error

 2003 Prentice Hall, Inc. All rights reserved.