Exception Handling in Java:
at Murphy’s Law, “If anything simply cannot go wrong, it will anyway,” we know
that we should always prepare ourself for the worst-case scenario.
don’t always turn out how we expect them to, and if anything can go wrong, it
probably will. When this happens in real life, there may not be a remedial solution.
Fortunately, in programming, if anything goes wrong, there is always a remedial
action for us to take—this is called exception handling. When something
goes wrong in our program, we say that an exception occurred. When we take a
remedial action on it, we say that we handled the exception. Here is a famous
quote by Douglas Adams:
The major difference between a thing that
might go wrong and a thing that cannot possibly go wrong is that when a thing
that cannot possibly go wrong goes wrong, it usually turns out to be impossible
to get at or repair.
substantiate this quote in sense of exception handling, let’s look at the most infamous
computer bug in history. Due to an error in the software design, Ariane
5 Flight 501, which took place on June 4, 1996, failed within 40
seconds with a loss of a half-billion dollars. The reason? A tiny software
bug. It occurred due to an exception thrown by some code that had originally
been written for the earlier version of the rocket, Ariane 4. This particular
routine, which could not be taken out easily, was left running although it was
not really needed during flight. The code computed a big number that it tried
to store in a short data type, causing an overflow condition. The program did
not have a handler to catch this situation. Even an empty error handler would
have probably saved the situation. But in the absence of an error handler, the
error propagated to the operating system, which terminated the program.
Unfortunately, the program was the guidance program for the rocket. All other computers
on the flight had the same code and all of them crashed. Without any guidance,
the rocket destroyed itself, which it was supposed to do in such a case.
this story, we can certainly see the importance of exception handling. The
proper use of exception handling can answer three basic questions:
What went wrong?
Where did it go wrong?
Why did it go wrong?
type of exception informs us of “what” went wrong. The exception stack trace
tells us “where,” and the exception message answers “why.” To make the best use
of exceptions, we need to follow three recommended rules:
have likely experienced errors while running many off-the-shelf applications on
our machine. When an application error occurs, probably the application
terminates abnormally and we have to redo everything we have done so far after
restarting the application. An application error may occur due to several
conditions, some of which may be beyond our control. For example, a network
connection may get disrupted or a file that the application is trying to open may
not exist. The application may try to access an out-of-bounds memory location,
or the .class file the application needs may be missing. An application can
fail under several such conditions.