Java Programming
Unit 5
Unit 5
Exception Handling
Structure
5.1
Introduction
Objectives
5.2
Definition of an Exception
Self Assessment Questions
5.3
Exception Classes
Self Assessment Questions
5.4
Common Exceptions
Self Assessment Questions
5.5
Exception Handling Techniques
5.6
Summary
5.7
Terminal Questions
5.1 Introduction
Though it is the dream to every programmer to write error-free programs it is
not so normally. This is because the programmer has not anticipated all
possible situations that might occur while running the program. The errors
might be due to situations that might occur while running the program. The
errors might be due to a programming mistake, bad input data, corrupts files
or problems in physical devices. It is necessary to take care about these
situations. The possible remedies could be to
Notify the user of an error.
Save the work environment.
Allowing exiting from the program without adversely affecting the other
programs in execution.
Objectives
In this chapter, you will learn about the:
Sikkim Manipal University
Page No. 120
Java Programming
Unit 5
Definition of Exception
Exception Classes
Exception handling techniques.
This unit aims at providing information about handling situations occurring
due to error or faulty conditions. This unit explains the mechanisms
available in Java to handle such situations. The error or exception handling
mechanisms in Java enables programmers to write more robust and secure
codes. Java enforces the programmers to specify the exceptions that might
occur while executing a method.
5.2 Definition of an Exception
The term exception denotes an exceptional event. It can be defined as an
abnormal event that occurs during program execution and disrupts the
normal flow of instruction.
Error-handling becomes a necessity when you develop applications that
need to take care of unexpected situations. The unexpected situations that
may occur during program execution are:
Running out of memory
Resource allocation errors.
Inability to find a file.
Problems in network connectivity.
If an above-mentioned situation is encountered, a program may stop
working. You cannot afford to have an application stop working or crashing,
if the requested file is not present on the disk. Traditionally, programmers
used return values of methods to detect the errors that occurred at runtime.
A variable errno was used for a numeric representation of the error. When
multiple errors occurred in a method, errno would have only one value-that
of the last error that occurred in the method.
Sikkim Manipal University
Page No. 121
Java Programming
Unit 5
Java handles exceptions the object-oriented way. You can use a hierarchy
of exception classes to manage runtime errors.
Self Assessment Questions
1. What is an Exception?
2. The term exception denotes an ________.
3. Java handles exceptions the ______________ way.
5.3 Exception Classes
The class at the top of the exception classes hierarchy is called Throwable.
Two classes are derived from the Throwable class- Error and Exception.
The Exception class is used fro the exceptional conditions that have to be
trapped in a program. The Error class defines a condition that does not
occur under normal circumstances. In other words, the Error class is used
for catastrophic failures such as VirtualMachineError. These classes are
available in the java.lang package.
Self Assessment Questions
1. What do you mean by Throwable?
2. What are the two classes that are derived from the throwable class?
3. In which packages of java, Exception classes are available?
5.4 Common Exceptions
Java has several predefined exceptions. The most common exceptions that
you may encounter are described below.
Arithmetic Exception
This exception is thrown when an exceptional arithmetic condition has
occurred. For example, a division by zero generates such an exception.
NullPointer Exception
This exception is thrown when an application attempts to use null where
an object is required. An object that has not been allocated memory
Sikkim Manipal University
Page No. 122
Java Programming
Unit 5
holds a null value. The situations in which an exception is thrown
include:
Using an object without allocating memory for it.
Calling the methods of a null object.
Accessing or modifying the attributes of a null object.
ArrayIndexOutOfBounds Exception
The exception ArrayIndexOutOfBounds Exception is thrown when an
attempt is made to access an array element beyond the index of the
array. For example, if you try to access the eleventh element of an array
thats has only ten elements, the exception will be thrown.
Self Assessment Questions
1. What do you mean by ArrayIndexOutOfBounds Exception?
2. What do you mean by NullPointer Exception?
5.5 Exception Handling Techniques
When an unexpected error occurs in a method, Java creates an object of
the appropriate exception class. After creating the exception objects, Java
passes it to the program, by an action called throwing an exception. The
exception object contains information about the type of error and the state of
the program when the exception occurred. You need to handle the
exception using exception-handler and process the exception.
You can implement exception-handling in your program by using following
keywords:
try
catch
finally
Sikkim Manipal University
Page No. 123
Java Programming
Unit 5
The try Block
You need to guard the statements that may throw an exception in the try
block. The following skeletal code illustrates the use of the try block
try
{
// statement that may cause an exception
}
The try block governs the statements that are enclosed within it and defines
the scope of the exception handlers associated with it. In other words, if an
exception occurs within try block, the appropriate exception-handler that is
associated with the try block handles the exception. A try block must have at
least one catch block that follow it immediately.
Nested try Statements
The try statement can be nested. That is, a try statement can be inside the
block of another try. Each time a try statement is entered, the context of
that exception is pushed on the stack. If an inner try statement does not
have a catch handler for a particular exception, the stack is unwound and
the next try statement's catch handlers are inspected for a match. This
continues until one of the catch statements succeeds, or until all of the
nested try statements are exhausted. If no catch statement matches, then
the Java run-time system will handle the exception. Here is an example that
uses nested try
statements:
// An example of nested try statements.
class NestTry {
public static void main(String args[ ]) {
try {
int a = args.length;
Sikkim Manipal University
Page No. 124
Java Programming
Unit 5
/* If no command-line args are present,
the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
try { // nested try block
/* If one command-line arg is used,
then a divide-by-zero exception
will be generated by the following code. */
if(a==1) a = a/(a-a); // division by zero
/* If two command-line args are used,
then generate an out-of-bounds exception. */
if(a==2) {
int c[ ] = { 1 };
c[42] = 99; // generate an out-of-bounds exception
}
} catch(ArrayIndexOutOfBoundsException e) {
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
As you can see, this program nests one try block within another. The
program works as follows. When you execute the program with no
Sikkim Manipal University
Page No. 125
Java Programming
Unit 5
command-line arguments, a divide-by zero exception is generated by the
outer try block. Execution of the program by one command-line argument
generates a divide-by-zero exception from within the nested try block. Since
the inner block does not catch this exception, it is passed on to the outer try
block, where it is handled. If you execute the program with two commandline arguments, an array boundary exception is generated from within the
inner try block. Here are sample runs that illustrate each case:
C:\\>java NestTry
Divide by 0: java.lang.ArithmeticException: / by zero
C:\\>java NestTry One
a=1
Divide by 0: java.lang.ArithmeticException: / by zero
C:\\>java NestTry One Two
a=2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException: 42
Nesting of try statements can occur in less obvious ways when method calls
are involved. For example, you can enclose a call to a method within a try
block. Inside that method is another try statement. In this case, the try
within the method is still nested inside the outer try block, which calls the
method. Here is the previous program recoded so that the nested try block
is moved inside the method nesttry( ):
/* Try statements can be implicitly nested via
calls to methods. */
class MethNestTry {
Sikkim Manipal University
Page No. 126
Java Programming
Unit 5
static void nesttry(int a) {
try { // nested try block
/* If one command-line arg is used,
then a divide-by-zero exception
will be generated by the following code. */
if(a==1) a = a/(a-a); // division by zero
/* If two command-line args are used,
then generate an out-of-bounds exception. */
if(a==2) {
int c[ ] = { 1 };
c[42] = 99; // generate an out-of-bounds exception
}
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out-of-bounds: " + e);
}
}
public static void main(String args[ ]) {
try {
int a = args.length;
/* If no command-line args are present,
the following statement will generate
a divide-by-zero exception. */
int b = 42 / a;
System.out.println("a = " + a);
nesttry(a);
Sikkim Manipal University
Page No. 127
Java Programming
Unit 5
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
The output of this program is identical to that of the preceding example.
The catch Block
You associate an exception-handler with the try block by providing one or
more catch handlers immediately after try block. The following skeletal code
illustrates the use of the catch block.
try
{
//statements that may cause an exception
}
catch ()
{
// error handling code
}
The catch statement takes an object of an exception class as a parameter. If
an exception is thrown, the statements in the catch block are executed. The
scope of the catch block is restricted to the statements in the preceding try
block only.
The finally Block
When an exception is raised, the rest of the statements in the try block are
ignored. Sometimes, it is necessary to process certain statements
irrespective of whether an exception is raised or not. The finally block is
used for this purpose.
Sikkim Manipal University
Page No. 128
Java Programming
Unit 5
try
{
openFile();
writeFile(); //may cause an exception
}
catch ()
{
//process the exception
}
In the above example, the file has to be closed irrespective of whether an
exception is raised or not. You can place the code to close the file in both
the try and catch blocks. To avoid duplication of code, you can place the
code in the finally block. The code in the finally block is executed regardless
of whether an exception is thrown or not. The finally block follows the catch
blocks. You have only one finally block for an exception-handler. However, it
is not mandatory to have a finally block.
finally
{
closeFile ();
}
5.6 Summary
Handling Runtime Exception
The term exception denotes an exceptional event. It can be defined as a
abnormal event that occurs during program execution and disrupts the
normal flow of instructions. The Exception class is used for the exceptional
conditions that have to be trapped in a program.
Sikkim Manipal University
Page No. 129
Java Programming
Unit 5
Java has several predefined exceptions. The most common exceptions that
you may encounter are:
Arithmetic Exception
NullPointer Exception
ArrayIndexOutOfBounds Exception
The following keywords are used for exception-handlings:
try
catch
finally
If an exception occurs within the try block, the appropriate exception-handler
that it associated with the try block handles the exception.
You associate an exception-handler with the try block by providing one or
more catch handlers immediately after the try block.
Sometimes, it is necessary to process certain statements, no matter
whether an exception is raised or not. The finally block is used for this
purpose.
5.7 Terminal Questions
1. What is the difference between errors and exceptions?
2. Why runtime exceptions need not be caught or specified?
3. Give 3 examples for runtime exception?
4. Write a program to copy one file to another file?
5. What are the different types of Exception?
6. What are the different Exception handling techniques?
Sikkim Manipal University
Page No. 130
