Professional Documents
Culture Documents
Exception Handling
Objectives
• Chapter 13
• Exceptions
• Exception handling
• Declaring exception
• Throwing exception
• Catching exception
• Different types of exceptions
• Error vs. Exception
• Checked vs. unchecked
• Keywords
• try, catch, finally
• throw, throws
Motivation
• When a program runs into a runtime error, the
program terminates abnormally.
• How can you handle the runtime error so that
the program can continue to run or terminate
gracefully?
Exceptions
Program
• Show runtime error
Quotient Run
Program
• Fix it using an if statement
QuotientWithIf Run
Previously
• Exceptions
• Motivation
Program
• What if the runtime error occurs in a called
method?
QuotientWithException Run
Program
• The advantages of using exception handling:
• It enables a method to throw an exception to its
caller.
• Without this capability, a method must handle the
exception or
• terminate the program.
QuotientWithMethod Run
Program
• By handling InputMismatchException, your
program will continuously read an input until it is
correct.
InputMismatch Run
Exception Hierarchy
• Exception Types
Exception Hierarchy
• Example
• Example
Catching Exception
• Exceptions
• Used in conjunction with methods
• 3 steps
• Declare (throws)
• Throw (throw)
• Catch (try-catch)
• Checked vs. unchecked
Catching Exception
TestCircleWithException CircleWithException
Run
Rethrow
• Rethrwoing exceptions
finally
• Occasionally, you may want some code to be
executed regardless of whether an exception
occurs or is caught.
Trace Program
Suppose no exceptions in
the statements
try {
statements;
}
catch(TheException ex) {
//handling ex;
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statements;
}
catch(TheException ex) {
//handling ex; The final block is always
executed
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statements;
}
catch(TheException ex) {
//handling ex;
}
finally {
//finalStatements; Next statement in the
method is executed
}
//Next statement ..
Trace Program
try { Suppose an exception of
statement1; type Exception1 is thrown in
statement2; statement2
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2;
throw x
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
} The exception is handled.
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2;
throw x
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) { The final block is always
//handling ex2; executed.
throw x
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2;
throw x
} The next statement in the
finally { method is now executed.
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2; statement2 throws an
statement3; exception of type Exception2.
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2;
throw x
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2; Handling exception
throw x
}
finally {
//finalStatements;
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2;
throw x
}
finally {
//finalStatements; Execute the final block
}
//Next statement ..
Trace Program
try {
statement1;
statement2;
statement3;
}
catch(Exception1 ex1) {
//handling ex1;
}
catch(Exception2 ex2) {
//handling ex2; Rethrow the exception
throw x and control is
transferred to the caller
}
finally {
//finalStatements;
}
//Next statement ..
Caution!
• Exception handling separates error-handling code
from normal programming tasks.
• Thus making programs easier to read and to
modify.
• Be aware, however, that exception handling
usually requires more time and resources because
it requires
• instantiating a new exception object,
• rolling back the call stack, and
• propagating the errors to the calling methods.
When?
• When to use exceptions:
1. An exception occurs in a method:
• If you want the exception to be processed by its
caller, you should create an exception object and
throw it.
• If you can handle the exception in the method
where it occurs, there is no need to throw it.
When?
• When should you use the try-catch block in the
code?
• You should use it to deal with unexpected error
conditions.
• Do not use it to deal with simple, expected
situations.
When?
• Example
When?
• Same example, better
Custom Exceptions
InvalidRadiusException
CircleWithRadiusException Run
TestCircleWithRadiusException