Lecture 23,24

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

• “System errors” are thrown by JVM and

represented in the Error class.
• E.g. Linkage error, VirtualMachineError, …
• The Error class describes internal system errors.
• Such errors rarely occur.
• If one does, there is little you can do beyond
notifying the user and trying to terminate the
program gracefully.
 Exception Hierarchy

• “Exception” describes errors caused by your

program and external circumstances.
• E.g. RuntimeException, IOException,
ClassNotFoundException, …
• These errors can be caught and handled by your
program.
 Exception Hierarchy

• “RuntimeException” is caused by programming

errors, such as bad casting, accessing an out-of-
bounds array, and numeric errors.
• E.g. ArithmaticException, NulPointerException,
IndexOfBoundException,
IllegalArgumentException,…
 Checked

• RuntimeException, Error and their subclasses are

known as unchecked exceptions.
• All other exceptions are known as checked
exceptions, meaning that
• the compiler forces the programmer to check and
deal with the exceptions.
 Checked

• In most cases, unchecked exceptions reflect

programming logic errors that are not recoverable.
• E.g. NullPointerException or
IndexOutOfBoundsException
• To avoid cumbersome overuse of try-catch blocks,
Java does not mandate you to write code to catch
unchecked exceptions.
 Exception Handling

• Exception handling process

1. Declare exception
2. Throw exception
3. Catch exception
 Declaring Exception

• Every method must state the types of checked

exceptions it might throw.
• This is known as declaring exceptions.
 Throwing Exception

• When the program detects an error, the program

can create an instance of an appropriate
exception type and throw it.
• This is known as throwing an exception.
 Throwing Exception

• Example

/** Set a new radius */

public void setRadius(double newRadius)
throws IllegalArgumentException
{
if (newRadius >= 0)
radius = newRadius;
else
throw new IllegalArgumentException(
"Radius cannot be negative");
}
 Catching Exception

• Example
 Catching Exception

• Exception handling example

 Previously

• Exceptions
• Used in conjunction with methods
• 3 steps
• Declare (throws)
• Throw (throw)
• Catch (try-catch)
• Checked vs. unchecked
 Catching Exception

• Java forces you to deal with checked exceptions.

• IOException
• If a method declares a checked exception you
must
1. invoke it in a try-catch block or
2. declare to throw the exception in the calling
method.
 Catching Exception

• For example, you have to write the code as shown in

(a) or (b).
 Catching Exception

• The order in which exceptions are specified in catch

blocks is important.
• A compile error will result if a catch block for a
superclass type appears before a catch block for a
subclass type.
 Program
• This example demonstrates declaring, throwing,
and catching exceptions by modifying the
setRadius method in the Circle class.
• The new setRadius method throws an exception if
radius is negative.

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

• Use the exception classes in the API whenever

possible.
• Define custom exception classes if the predefined
classes are not sufficient.
• Define custom exception classes by extending
Exception or a subclass of Exception.
 Program
• Custom Exception

InvalidRadiusException

CircleWithRadiusException Run

TestCircleWithRadiusException