Transcript Analysis

Exception Handling
Yaodong Bi
[email protected]
Exception Handling









Java exception handling
Try blocks
Throwing and re-throwing an exception
Catching an exception
Throws clause
Exceptions in constructors and finalizers
Exception and inheritance
The finally block
PrintStackTrace() and getMessage()
Java Exception Handling



To process only exceptional situations where a method
is unable to complete the task for reasons it cannot
control
To process exceptions from program components that
are not geared to handling those exceptions directly
To process exceptions from components such as
libraries and classes that are likely to be widely used
and where those components cannot handle their own
exceptions
Java Exception Handling



When an exception does not occur, little or no
overhead is imposed by the presence of
exception handling code.
When exceptions occur, they do incur
execution-time overhead
Use Java’s standardized exception handling to
improve program clarity and fault tolerance
Exception Handling Basics





When a block of code (ex., a method) detects an
error it cannot handle, it throws an exception
The programmer encloses in a try block the code that
may throw an exception.
The try block is immediately followed by zero or more
catch blocks to catch the exception(s)
Each catch block specifies the type of exception it
can catch and contains an exception handler
An optional finally block (mandatory when no catch
clause provided) will be executed regardless of
whether or not there is an exception.
Exception Handling Basic


A method can use a throws clause to specify
what exceptions it may throw
Java employs the termination model of
exception handling.
–
Once an exception is thrown, the block in which
the exception is thrown terminates and control
cannot return to the throw point
Ex. 1: Divide By Zero
public class ExceptionHandling
{
public static int quotient(int numerator, int denominator)
throws DivideByZeroException
{
if (denominator == 0)
throw new DivideByZeroException();
return numerator / denominator;
}
public static void main(String[] arg)
{
try {
quotient(100, 0);
}
catch (DivideByZeroException e)
{
System.err.println(e.toString());
}
Ex. 1: Divide By Zero
finally
{
System.out.println("Finally Block");
}
}
}
// the following is saved in a separate file
public class DivideByZeroException extends ArithmeticException
{
public DivideByZeroException()
{
super("Divide by Zero");
}
public DivideByZeroException(String s)
{
super(s);
}
}
Try blocks
try {
// code that may throw exceptions
}
catch (ExceptionType ref)
{
// exception handler
}



A try block can be followed by zero or more catch blocks
If the try block executes with no exception thrown, all the
exception handlers are skipped and control resumes with
the first statement after the last exception handler
If a finally block follows the last catch block, it will be
executed regardless of whether or not an exception is
thrown
Throwing Exceptions

The throw statement makes an exception to occur –
throwing an exception
–



throw new DivideByZeroException();
A throw statement must throw an object of any class
derived from class Throwable
When an exception is thrown, control exits the current
try block and proceeds to an appropriate catch handler
When toString() is invoked on any Throwable object, it
returns the String that was supplied to the constructor
public class DivideByZeroException extends ArithmeticException
{
public DivideByZeroException()
{
super("Divide by Zero"); // return by toString()
}
Catching Exceptions


Each catch block starts with the keyword catch
followed by parentheses containing a class name (type
of exception)
The Exception object caught can be referred through
the parameter
catch (ExceptionType ref)
{
// using ref to refer to the exception object
}

It is possible that several handlers provide an
acceptable match to the type of the exception, the first
exception handler that matches the exception type is
executed.
Catching Exceptions



Each catch block defines a distinct scope
An exception handler cannot access objects defined in
other handlers
Objects defined in a try block cannot be accessed in its
exception handlers
try
{
int tryX = 100; …
}
catch (ExceptionType1 ref)
{
int catch1Y = 200;
// tryX is NOT accessible here
}
catch (ExceptionType2 ref)
{
// both tryX and catch1Y are NOT accessible here
}
Catching Exceptions

Exceptions thrown from a handler cannot be caught by
the catch blocks of the current try-catch structure
1 try {
2
try { throw new ExcType1(); }
3
catch (ExcType1 ref)
4
{
5
throw new ExcType2();
6
}
7
catch (ExcType2 ref)
8
{
9
// this will NOT catch the ExcType2 thrown from line 5
10
}
11 catch (ExcType2 ref)
12 {
13
// catch the ExcType2 exception thrown from line 5
14 }
Re-throwing Exceptions


When a exception handler cannot or does not want to
handle the caught exception completely, it can re-throw
the exception using the throw statement.
Such a re-thrown exception is handled by the enclosing
try-catch block
1 try {
2
try { throw new ExcType1(); }
3
catch (ExcType1 ref)
4
{
5
throw ref;
6
}
7 catch (ExcType1 ref)
8 {
9
// catch the ExcType1 exception thrown from line 5
10 }
Throws Clause

A throws clause lists the exceptions that can be thrown
by a method
void foo() throws ExceptionA, ExceptionB ExceptionA
{
// may throw the above three exceptions }


All exceptions must be handled exception Error and
RuntimeException
If a method does not handle exceptions that may be
thrown from its body, it must use the throws clause for
the caller to handle the exceptions
public void addCourse(String cid, String ttl)
throws SQLException
{
…
st.executeUpdate(sql); // may throw SQLException
}
Java Exception Hierarchy
Object
Throwable
Error
LinkageError
Exception
AWTError
RuntimeException
ClassNotFoundException
NoSuchMethodException
Must be handled
ArithmeticException
ArrayStoreException
Java Exception Hierarchy


You can throw only objects that derive from the
Throwable class.
Errors:
–
–

When a "hard" failure in the virtual machine occurs, the virtual
machine throws an Error.
Typical Java programs should not catch Errors and it's
unlikely that typical Java programs will ever throw Errors
either.
Exceptions:
–
–
Most programs throw and catch objects that derive from the
Exception class.
Exception has a special subclass RuntimeException which is
not required to be handled
Runtime Exceptions

The RuntimeException class represents exceptions that occur
within the Java virtual machine (during runtime).
–




An example of a runtime exception is NullPointerException.
The Java packages define several RuntimeException classes. You
can catch these exceptions just like other exceptions.
A method is not required to specify that it throws
RuntimeExceptions.
The cost of checking for all RuntimeExceptions often outweighs the
benefit of catching it.
the compiler allows RuntimeExceptions to go uncaught and
unspecified.
Exception and Inheritance

If a catch is written to catch exception objects of a
superclass type, it can also catch all objects of
subclasses of that superclass
–


catch (Exception e) { } would catch almost all exceptions
This also allows for polymorphic processing of related
exceptions
It is a syntax error if a catch that catches a superclass
object is placed before a catch that catches an object
of a subclass of that superclass
The finally Block


The finally block is optional; if it present it must be
placed after the last catch block
The finally block can be used to control resource leaks
try
{
// may throw exceptions
}
catch (ExceptionType1 ref)
{
// exception handling statements
}
catch (ExceptionType2 ref)
{
// exception handling statements
}
finally
{
// statements
// resource release statements
}
The finally Block

A finally block will be executed (if present) regardless
of whether or not any exception is thrown and
regardless of whether the exception is handled or not.
–
–
–
–
If there is no exception, it will be executed after the try block
If there is an exception and it is handled by a handler, it will be
executed after the catch is completed
If there is an exception and it is not handled by a catch, it will
be executed after the termination of the try block and then the
exception is passed to to next level
If there is an exception in a catch block, it will be executed
after the catch block terminates and then the exception is
passed to next level
printStackTrace() and getMessage()



Class Throwable offers a printStackTrace
method that prints the method call stack
Class Exception inherits the method
Two constuctors for Exception
public Exception()
//accept no parameter
public Exception(String str) // accept a string
–
The str stored in Exception may be queried with
method getMessage()
printStackTrace & getMessage()
public class ExceptionHandling
{ public static int quotient(int numerator, int denominator)
throws DivideByZeroException
{
if (denominator == 0)
throw new DivideByZeroException();
return numerator / denominator;
}
public static void main(String[] arg)
{
try {
quotient(100, 0);
}
catch (DivideByZeroException e)
{
System.err.println(e.getMessage());
e.printStackTrace();
}
}
}
printStackTrace & getMessage()

The following will be printed by the program
– Printed by
Divide by Zero
getMessage()
– Printed by printStackTrace()
DivideByZeroException: Divide by Zero
at ExceptionHandling.quotient(ExceptionHandling.java:7)
at ExceptionHandling.main(ExceptionHandling.java:15)