Java
has many wonderful things and exception handling is one among them. Exception
handling is a framework provided by Java to ensure program execution continues
in an unfavorable problem condition by handling it gracefully. Exception
handling is not new to Java guys and I need not give a heroic introduction to
it. This is my attempt at writing a detailed tutorial like a chapter in a Java
book, by giving comprehensive coverage to this topic accompanied by code
examples, images, bells and whistles. I will give a simple and easy to
understand narrative to java exception handling and try to uncover intricate
detail as much as possible in my own style. As exception handling is a large
topic, this will be a multi-part series.
I
chose to use the word problem instead of error in the above definition. Error
is a java class and given a specific meaning in Java exception handling and I
didn’t want that to be mixed with the general English word which denotes an
unfavorable condition. Google says, problem is “A matter or situation regarded
as unwelcome or harmful and needing to be dealt with and overcome”. In general
software terms we use error to signify that and they are of two types, compile
time and run time. In exception handling we will be dealing only with run-time
problems. In any software program, there are numerous possibilities that a
problem can occur at run-time during the flow of execution. How it is handled
is crucial to the business and user. Right from Ada to C++ to PHP exception
handling is available.
Imagine
if there is no exception handling mechanism available and what would happen if
a run time error occurs. Most likely the program may crash in ugly manner
resulting in an un wanted situation. In those situations, we can analyze the
programs and use if-condition construct and try to salvage the situation.
Repair the code and re-run it. Some problems cannot be handled and will result
in reporting error code and abruptly discontinue the execution. All these will
result in unorganized / non maintainable code. With Java’s exception handling
mechanism we have an organized and simplified more importantly object oriented
way of handling run-time problems.
How
Exception Handling works?
At low level
an exception is a java object with attributes and methods. When a problem
occurs, an exception object is created, thrown and then handled.
As shown in above figure, exception handling can be grouped
into these four phases. When a problem occurs it is the start of exception
handling flow. A problem can be broadly classified into two. First one is, it
can be handled and execution can continue, the second one is an unrecoverable
serious situation which cannot be handled. An example for recoverable problem
is, code block is expecting a value in a variable and it is not present. This
can be handled by substituting a default value and the execution can continue.
An easy example for unrecoverable condition is a hardware failure.
Java’s exception handling mechanism is object oriented. We
have Throwable as the base class and all exceptions are sub classes of
Throwable. We have Error and Exception as two immediate sub classes of
Throwable.
When
to use Exception Handling?
Exception
handling should be used judiciously. Earlier I wrote about fail fast vs fail
safe and that article loosely relates to this context and my personal
preference is to fail fast. Exception handling does not mean that we should
take the program flow in an alternate direction than the intended one and which
may cause issues in future. We should be cautious when we say handling, as in
the name of handling, an issue should not be carried over to a different
context of the program as it will come back to haunt us.
So when do we
use exception handling, it is when we foresee that a problem may occur at run
time and we know a possible solution to it at design time itself. Then at run
time if that solution path is chosen it should not alter the core objective of
the program. Cases like, just logging the problem and proceeding with the flow
does not fit into exception handling. A popular mistake done by java developers
is to use exception handling for flow control. Though we have if-else and other
options, we tend to fall on exception handling side and use it as flow control
mechanism which is poor.
Exception
Handling Keywords
throw
Exceptions can
be thrown by either java run time environment or by the code itself. JRE throws
exception when java’s rules are violated. An example is, when the code accesses
an array location which is not available then ArrayIndexOutOfBoundsException is
thrown. Pretty nice name right and obviously it explains the problem. All the
java exception classes are not having any attributes and standard methods. It
is a common design. Class name describes what exception it is and the hierarchy
forms an organization chart kind of structure using which java exceptions are
used.
Programmers
can throw an exception to indicate a problem condition. Either java’s
predefined exceptions can be used or custom exceptions can be created by
extending the already available exceptions. Programmer can throw a custom
exception or a predefined Java exception. Mostly custom exceptions are created
based on business conditions. Programmer can use the Java keyword ‘throw‘ to
generate an exception. It is done by instantiating the exception class of choice
and then thrown.
try
– catch
A thrown
exception should be handled. If the program does not handles an exception, then
it will be handled by the java run time environment. A block of code where an
exception is expected should be surrounded by try – catch block. try indicates
the start of the exception handling block and catch the end of the block.
Following catch a block of code can be written which is the exception handling
code block. This is the part the handles the exception. A catch will have an
exception identified and it will catch only that type of exception. Type means
the same exception and all its sub classes. There can be multiple catch blocks
for a try block.
throws
When a Java
method is going to throw an exception, to indicate that as part of the method
signature ‘throws‘ keyword should be used followed by the exception. It means
that the caller of this method should handle the exception given in the throws
clause. There can be multiple exceptions declared to be thown by a method. If
the caller of that method does not handles the exception, then it propagates to
one level higher in the method call stack to the previous caller and similarly
till it reaches base of the method call stack which will be the java’s run time
system.
finally
After catch
block there can be one more block of code declared as ‘finally‘. Irrespective
of whether an exception is thrown or not, the finally block of code will always
be executed. Important piece of code that must be executed, even if a program
fails belong to this finally block. Example would be closing a database
connection, a file handle, etc.
General
Exception Handling Structure
try
{
// possible exception code block
}
catch (ExceptionTypeA exception1) {
// handle exception of type
ExceptionTypeA and all it subclasses
}
catch (ExceptionTypeB exception2) {
// handle exception of type
ExceptionTypeB and all it subclasses
}
finally {
// guarantee block: executes always
irrespective of exception
}
Post a Comment