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.10 Declaring New Exception Types
15.11 Constructors and Exception Handling

1
15.1 Introduction

 Exception handling
 Exception is an indication of problem during execution
 “exception” occurs infrequently
 e.g., divide by zero
 Promotes robust and fault-tolerant software
 Java’s Exception Handling nearly identical to C++

2
15.2 Exception-Handling
Overview
 Mixing program code with error-handling code makes
program difficult to read, modify, maintain, debug
 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

3
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
immediately
 throws clause specifies exceptions method throws (or
by methods it calls)
 Simple problems that can easily be fixed can be handled
as “errors”
 Use Exception Handling for more complicated situations

4
15.2 Exception-Handling
Overview
 Typical exceptions – array index out of range, overflow,
division by zero, invalid method parameters, memory
allocation problems
 Most significant use of Exception Handling – problem
occurs in a method, but resolution must be done in
calling method (one or more levels above)
 Method that detects problem “throws an exception”
 Method that resolves problem “catches the exception”

5
15.3 Exception-Handling
Example: Divide by Zero
 Common programming mistake
 Throws ArithmeticException
 NumberFormatException is thrown if parseInt,
parseDouble, etc. are given bad strings
 Program catches an exception in an “appropriate” catch
block (same class or superclass)
 Program continues executing with code after the last
catch block (not back inside the try block)

6
 1 // Fig. 15.1: DivideByZeroTest.java

2 // An exception-handling example that checks for divide-by-zero.

3 import java.awt.*;

4 import java.awt.event.*;

5 import javax.swing.*;

7 public class DivideByZeroTest extends JFrame

8 implements ActionListener {

10 private JTextField inputField1, inputField2, outputField;

11 private int number1, number2, result;

DivideByZeroT
12

13 // set up GUI

14 public DivideByZeroTest()

15 {

est.java
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 );

7
est.java
29
28 // set up label and inputField2; register listener

container.add( new JLabel( "Enter denominator and press Enter ",

27

30 SwingConstants.RIGHT ) );

31 inputField2 = new JTextField();

32 container.add( inputField2 );

33 inputField2.addActionListener( this );

Line 51
34

35 // set up label and outputField

36 container.add( new JLabel( "RESULT ", SwingConstants.RIGHT ) );

37 outputField = new JTextField();

38 container.add( outputField );

39

40 setSize( 425, 100 );

41 setVisible( true );

Lines 52-53
42

43 } // end DivideByZeroTest constructor

44

45 // process GUI events

46 public void actionPerformed( ActionEvent event )

The try block
47 {

48 outputField.setText( "" ); // clear outputField

Read integers from

49

50 JTextFields
// read two numbers and calculate quotient

51 try {

52 number1 = Integer.parseInt( inputField1.getText() );

53 number2 = Integer.parseInt( inputField2.getText() );

8
 Line 60
55

56
54

result = quotient( number1, number2 );

outputField.setText( String.valueOf( result ) );

Method
quotient
attempts division
57 }

58

59 // process improperly formatted input

60 catch ( NumberFormatException numberFormatException ) { Catch

NumberFormatExcepti
Line 67
61 JOptionPane.showMessageDialog( this,

on
62 "You must enter two integers", "Invalid Number Format",

63 JOptionPane.ERROR_MESSAGE );

64 }

65

66 // process attempts to divide by zero

67 catch ( ArithmeticException arithmeticException ) { Catch

68 JOptionPane.showMessageDialog( this,
ArithmeticException

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
Method quotient
throws ArithmeticException

throws
78 {

79 return numerator / denominator;

ArithmeticExcepti
80 }

on
9
 81

82 public static void main( String args[] )

83 {

84 DivideByZeroTest application = new DivideByZeroTest();

85 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

86 }

87

88 } // end class DivideByZeroTest

DivideByZeroT
est.java

10
15.4 Java Exception
Hierarchy
 Exceptions (like everything in Java) are objects
 Superclass Throwable
 Subclass Exception
 Exceptional situations
 Should be caught by program
 Subclass Error
 Typically not caught by program
 Checked exceptions (include any you create)
 “catch or declare” requirement
 Unchecked exceptions (subclass of RuntimeException,
e.g., NumberFormatException)
 Good idea to catch, but not required

11
Fig. 15.2 Inheritance hierarchy
for class Throwable
Throwable

Exception Error

RuntimeException IOException AWTError ThreadDeath OutOfMemoryError

12
15.5 Rethrowing an
Exception
 Rethrow exception if catch cannot handle it
 This typically involves a try block (with its catch blocks)
inside another try block
 Inner catch block throws it to the outer catch block … or
even on to the calling method

13
15.6 finally Clause

 Resource leak
 Caused when resources are not released by a program
 files, database connections, network connections
 The finally block (optional)
 Appears after catch blocks
 Always executes whether or not any exception is thrown
 Use to release resources (e.g., close file)

14
 1 // Fig. 15.3: UsingExceptions.java

2 // Demonstration of the try-catch-finally exception handling mechanism.

3 public class UsingExceptions {

5 public static void main( String args[] )

6 {

7 try {

8 throwException(); // call method throwException

9 }

10

11 // catch Exceptions thrown by method throwException

UsingExceptio
12 catch ( Exception exception ) {

13 System.err.println( "Exception handled in main" );

14 }

15

ns.java
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 }

15
 ns.java 28

29
27

// catch exception thrown in try block

catch ( Exception exception ) {

30 System.err.println(

31 "Exception handled in method throwException" );

Rethrow Exception
32 throw exception; // rethrow for further processing

33

Line 32
34 // any code here would not be reached

35 }

36

37 // this block executes regardless of what occurs in try/catch

38 finally {
The finally block
executes, even though
39 System.err.println( "Finally executed in throwException" );

40 }

Exception thrown
41

Lines 38-40
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 }

16
 53

54 // catch does not execute, because no exception thrown

55 catch ( Exception exception ) {

UsingExceptio
56 System.err.println( exception );

57 }

58

59 // this clause executes regardless of what occurs in try/catch

The finally

ns.java
60 finally {

61 System.err.println(
block always
62 "Finally executed in doesNotThrowException" );

63 }
executes
64

65 System.out.println( "End of method doesNotThrowException" );

66

67 } // end method doesNotThrowException

Lines 60-63
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

17
15.7 Stack Unwinding

 Exception not caught in scope

 Method terminates
 Stack unwinding occurs (all local variables go out of scope,
control reverts to statement that called method)
 Another attempt to catch exception (if this is inside a try
block)
 And on and on and on….

18
 Line 13 2
1 // Fig. 15.4: UsingExceptions.java

// Demonstration of stack unwinding.

3 public class UsingExceptions {

5 public static void main( String args[] )

6 {

7 // call throwException to demonstrate stack unwinding

Line 19
8 try {

9 Call method
throwException();

throwExceptio
10

11
}

12 // catch exception thrown in throwException n

13 Catch Exception from
catch ( Exception exception ) {

14 System.err.println( "Exception handled in main" );

method
15 }
throwExcetion

Line 24
16 }

17

18 // throwException throws exception that is not caught in this method

19 public static void throwException() throws Exception

20 {

21
Method declares a
// throw an exception and catch it in main

22 try {

23
throws clause
System.out.println( "Method throwException" );

24 throw new Exception(); // generate exception

25
Throw an
26
}

Exception

19
 27 // catch is incorrect type, so Exception is not caught

28 catch ( RuntimeException runtimeException ) {

29 System.err.println(

30 "Exception handled in method throwException" );

31 }

32

33 // finally clause always executes

34 finally {

35 System.err.println( "Finally is always executed" );

36 }

37

UsingExceptio
38 } // end method throwException

39

40 } // end class UsingExceptions

ns.java
 Method throwException
Finally is always executed
Exception handled in main

20
15.8 printStackTrace,
getStackTrace and
getMessage
 Throwable class
 Method printStackTrace
 Prints method call stack (helpful in debugging)
 Method getStackTrace
 Obtains stack-trace information
 Method getMessage
 Returns descriptive string
 Uncaught exception – default exception handler –
displays complete stack trace

21
 2
Line 8 1 // Fig. 15.5: UsingExceptions.java

// Demonstrating getMessage and printStackTrace from class Exception.

3 public class UsingExceptions {

5 public static void main( String args[] )

6 {

7 try {

Lines 13-14
Call method1
8 method1(); // call method1

9 }

10

11 // catch Exceptions thrown from method1

13
12
Print information
catch ( Exception exception ) {

System.err.println( exception.getMessage() + "\n" );

14 generated by
exception.printStackTrace();

getMessage and
15

Lines 25-26
printStackTrace
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 21

22
StackTraceElements
// 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" );

22
 27

28
Line 45
System.out.print( currentElement.getLineNumber() + "\t" );

System.out.print( currentElement.getMethodName() + "\n" );

29

30 } // end for statement

31

32
Print
} // end catch

33

StackTraceElements

Line 49
34 } // end method main

35

36 // call method2; throw exceptions back to main

37 method1 declares
public static void method1() throws Exception

a throw clause
38 {

Call method2
39 method2();

40 }

41

Line 51
42 // call method3; throw exceptions back to method1

43
method2 declares
public static void method2() throws Exception

a throw clause
44 {

45 method3();
Call method3
46 }

47

48 // throw Exception back to method2

49
method3 declares
public static void method3() throws Exception

a throw clause
50 {

51 throw new Exception( "Exception thrown in method3" );

Throw an
52 }

Exception that
propagates back to
23 main
 53
54 } // end class Using Exceptions

Exception thrown in method3

 
java.lang.Exception: Exception thrown in method3
at UsingExceptions.method3(UsingExceptions.java:51)
at UsingExceptions.method2(UsingExceptions.java:45)
at UsingExceptions.method1(UsingExceptions.java:39)
at UsingExceptions.main(UsingExceptions.java:8)
 

UsingExceptio
Stack trace from getStackTrace:
Class File Line Method
UsingExceptions UsingExceptions.java 51 method3
UsingExceptions UsingExceptions.java 45 method2

ns.java
UsingExceptions UsingExceptions.java 39 method1
UsingExceptions UsingExceptions.java 8 main

24
15.10 Declaring New
Exception Types
 Extend existing exception class

public class TooSmallException extends

ArithmeticException
{
public TooSmallException ()
{
super (“Value is less than 100”);
}
public TooSmallException (String message)
{
super (message);
}
}

25
15.11 Constructors and
Exception Handling
 Constructor cannot return a value to indicate an error
 Throw exception if constructor causes error
 For example, if invalid initialization value given to
constructor and there is no sensible way to correct this

26