Exception Handling
Exception Handling is the mechanism to handle runtime malfunctions. We need to handle such exceptions to prevent abrupt termination of program. The term exception means exceptional condition, it is a problem that may arise during the execution of program. A bunch of things can lead to exceptions, including programmer error, hardware failures, files that need to be opened cannot be found, resource exhaustion etc.
Exception
A Java Exception is an object that describes the exception that occurs in a program. When an exceptional events occurs in java, an exception is said to be thrown. The code that's responsible for doing something about the exception is called an exception handler.
Types of Exception
There are mainly two types of exceptions: checked and unchecked where error is considered as unchecked exception. The sun microsystem says there are three types of exceptions:
- Checked Exception
- Unchecked Exception
- Error
Difference between checked and unchecked exceptions
1) Checked Exception
The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions e.g.IOException, SQLException etc. Checked exceptions are checked at compile-time.
2) Unchecked Exception
The classes that extend RuntimeException are known as unchecked exceptions e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc. Unchecked exceptions are not checked at compile-time rather they are checked at runtime.
3) Error
Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError etc.
Java Exception Handling Keywords
There are 5 keywords used in java exception handling.
- try
- catch
- finally
- throw
- throws
Using try and catch
Try
is used to guard a block of code in which exception may occur. This block of
code is called guarded region. A catch statement involves declaring the type of
exception you are trying to catch. If an exception occurs in guarded code, the
catch block that follows the try is checked, if the type of exception that
occured is listed in the catch block then the exception is handed over to the
catch block which then handles it.
Syntax of
java try-catch
try{
//code that may throw exception
}catch(Exception_class_Name ref){}
Example
using Try and catch
class Excp
{
public static void main(String
args[])
{
int a,b,c;
try
{
a=0;
b=10;
c=b/a;
System.out.println("This
line will not be executed");
}
catch(ArithmeticException
e)
{
System.out.println("Divided
by zero");
}
System.out.println("After
exception is handled");
}
}
Output
Divided by zero
After exception is handled
Multiple Catch Blocks
A
try block can be followed by multiple catch blocks. The syntax for multiple
catch blocks looks like the following −
Syntax
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}
Let's see a simple example of
java multi-catch block.
public class TestMultipleCatchBlock{
public static void main(String args[]){
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e){System.out.println("task1 is completed");}
catch(ArrayIndexOutOfBoundsException e){System.out.println("task 2 completed");}
catch(Exception e){System.out.println("common task completed");}
System.out.println("rest of the code...");
}
}
Output:task1 completed
rest of the code...
Nested try statement
try statement can be nested inside another
block of try. Nested try block is used when a part of a block may
cause one error while entire block may cause another error. In case if
inner try block does not have a catch handler
for a particular exception then the outer try catch block is
checked for match.
class Excep
{
public static void main(String[]
args)
{
try
{
int arr[]={5,0,1,2};
try
{
int x=arr[3]/arr[1];
}
catch(ArithmeticException
ae)
{
System.out.println("divide
by zero");
}
arr[4]=3;
}
catch(ArrayIndexOutOfBoundsException
e)
{
System.out.println("array
index out of bound exception");
}
}
}
output
divide by zero
array index out of bound exception
finally block
is a block that is used to execute important code such as closing connection, stream etc.
Java finally block is always executed whether exception is handled or not.
Java finally block follows try or catch block.
class TestFinallyBlock{
public static void main(String args[]){
try{
int data=25/5;
System.out.println(data);
}
catch(NullPointerException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");}
System.out.println("rest of the code...");
}
}
throw Keyword
throw keyword is used to throw an exception explicitly. Only
object of Throwable class or its sub classes can be thrown. Program execution
stops on encountering throw statement, and the closest catch
statement is checked for matching type of exception.
Syntax :
throw ThrowableInstance
Example demonstrating throw
Keyword
class Test
{
static void avg()
{
try
{
throw new
ArithmeticException("demo");
}
catch(ArithmeticException e)
{
System.out.println("Exception
caught");
}
}
public static void
main(String args[])
{
avg();
}
}
throws Keyword
Any
method that is capable of causing exceptions must list all the exceptions
possible during its execution, so that anyone calling that method gets a prior
knowledge about which exceptions are to be handled. A method can do so by using
the throws keyword.
Syntax :
type method_name(parameter_list) throws exception_list
{
//definition of method
}
Example
class Test
{
static void check()
throws ArithmeticException
{
System.out.println("Inside
check function");
throw new ArithmeticException("demo");
}
public static void
main(String args[])
{
try
{
check();
}
catch(ArithmeticException
e)
{
System.out.println("caught"
+ e);
}
}
}
Output
Inside check function
No comments:
Post a Comment