Chapter 5: Exception

Handling
Writing Robust Java Codes

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 1
College
 Introduction
• Two cases exist when you design & code a
method
 The case where nothing unusual happens and
 The case where exceptional things happen.
• In Java, there is a way to deal with cases
where exceptional things can happen.
• The way is known as exception handling.
• It deals with methods that have some special
case that is handled differently depending on
how the method is used.
 Example: a method that handles division by zero.
CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 2
College
 Exception Types
• Exceptions are objects.
• Any class designed for throwable objects
must extend the class Throwable or one of its
subclasses.
• The Throwable class contains a string that
can be used to describe the exception it.
• Exceptions can be of two types:
 Checked Exceptions: the compiler checks that
your methods throw only the exceptions they
have declared themselves to throw.
 Unchecked Exceptions: conditions that reflect
errors
CS_Dept@Sata in your program's logic and cannot be
Technology
Object Oriented Programming - CoSc 2082 3
College
reasonably recovered from at run time.
 Exception types…

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 4
College
 Checked Exceptions
• Represent conditions that, although
exceptional, can reasonably be expected to
occur.
• If they do occur must be dealt with in some
way.
• Checking them ensures that the caller of a
method deals with the exception in some
way or at least consciously chooses to ignore
it.
• We have to explicitly specify these exception
during method definition.
 Eg. RemoteException
CS_Dept@Sata Technology
College in RMI- CoSc 2082
Object Oriented Programming 5
 Unchecked Exceptions
• Reflect errors in your program's logic.
• Cannot be reasonably recovered from at run
time.
• These are errors that should be corrected in
the program code.
• These are errors that should be corrected in
the program code.
• They are also called Runtime Exceptions.
 Eg. ArrayIndexOutOfBounsException: thrown
when you access outside the bounds of an array
• You might define a new class of runtime
CS_Dept@Sata Technology
exception that Object
College is specific to your application 6
Oriented Programming - CoSc 2082
 Error Class
• Defines a range of errors that indicate
something has failed in the virtual machine
itself (VirtualMachineError), or
• In the virtual machine's attempt to execute
your application (LinkageError).
• These are also unchecked because they are
beyond the applications ability to control, or
handle.
• Application code should rarely, if ever, throw
these error exceptions directly.

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 7
College
 How to handle
exceptions
• In Java, exception handling proceeds as
follows:
• Either some library software or your code
provides a mechanism that signals when
something unusual happens. This is called
throwing an exception.
• At another place in your program you place
the code that deals with the exceptional case.
This is called handling the exception.
• This method of programming makes for
cleaner code.
CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 8
College
 try-throw-catch
mechanism
• The basic way of handling exceptions in Java
consists of the try-throw-catch trio.
• The general setup consists of a try block
followed by one or more catch blocks.
• A try block has the syntax
try{
Some_Code
}
• This try block contains the code for the basic
algorithm that tells what to do when
everything goes smoothly.
CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 9
College
 try block….
• It “tries” to execute the case where all goes
smoothly.
• If something exceptional does happen, you
want to throw an exception.
 Indicates that something unusual happened.
• The basic outline, when we add a throw, is as
follows:
try{
Code_That_May_Throw_An_Exception
}

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 10
College
 throw...
• Example:
try{
if(denominator==0)
throw new Exception(“Division by zero”);
}
• The value thrown is an argument to the
throw operator and is always an object of
some exception class.
• The execution of a throw statement is called
throwing an exception.

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 11
College
 catch block
• A catch block begins execution when an
exception is thrown in the try block.
• The catch block has a parameter.
• Exception object thrown is plugged in for this
catch block parameter.
• Executing of the catch block is called catching
the exception or handling the exception.
• When an exception is thrown, it should ultimately
be handled by (caught by) some catch block.
• Catch block immediately follows the try block.

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 12
College
 catch block…
• Syntax of catch block looks like as follows:
catch (ExceptionClassName e){
//code to be executed in the catch block
}
• Example:
catch(Exception e){
String message = [Link]();
[Link](message);
[Link](0);
}

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 13
College
Declaring Exceptions in a throws
Clause
• If a method does not catch an exception, it
must at least warn that any invocation of the
method might possibly throw an exception.
• This warning is called a throws clause.
• Including an exception class in a throws
clause is called declaring the exception.
 For example, a method that might possibly throw
a DivisionByZeroException and that does not
catch the exception would have a heading similar
to the following:
• public void sampleMethod() throws
DivisionByZeroException
CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 14
College
 Declaring exceptions…
• If there is more than one possible exception that
can be thrown in the method definition, then the
exception types are separated by commas.
• public void sampleMethod() throws DivisionByZeroException,
SomeOtherException
• This technique is a form of shifting responsibility
(“passing the buck”).
• If you define a method that might throw
exceptions of some particular class, then normally
either
 Your method definition must include a catch block that
will catch the exception or
 You must declare (that is, list) the exception class within
a throws
CS_Dept@Sata Technologyclause.
Object Oriented Programming - CoSc 2082 15
College
 Catch or Declare Rule
• Most “ordinary” exceptions that might be
thrown when a method is invoked must be
accounted for in one of two ways:
 The possible exception can be caught in a catch
block within the method definition.
 The possible exception can be declared at the
start of the method definition by placing the
exception class name in a throws clause.
• This is known as the Catch or Declare Rule.
• In any one method, you can mix the two,
catching some exceptions and declaring
others in
CS_Dept@Sata Technology
a throws clause.
Object Oriented Programming - CoSc 2082 16
College
 The finally Block
• The finally block contains code to be executed whether or
not an exception is thrown in a try block.
• The finally block, if used, is placed after a try block and its
following catch blocks.
 The general syntax is as follows:
try{
...
}
catch(ExceptionClass1 e){
...
}
catch(ExceptionClassLast e){
...
}
finally{
< Code to be executed whether or not an exception is thrown or caught.>
}
CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 17
College
 finally block…
• There are three possibilities when the code in the
try-catch-finally blocks is run:
[Link] try block runs to the end and no exception is thrown.
• In this case, the finally block is executed after the try block.
[Link] exception is thrown in the try block and is caught in
one of the catch blocks positioned after the try block.
• In this case, the finally block is executed after the catch block is
executed.
[Link] exception is thrown in the try block and there is no
matching catch block in the method to catch the
exception.
• In this case, the method invocation ends and the exception object
is thrown to the enclosing method. However, the finally block is
executed before the method ends.

CS_Dept@Sata Technology
Object Oriented Programming - CoSc 2082 18
College