Exception Handling in Java

 Exception in Java
Dr. Turkan Ahmed Khalee
1
What is Exception in Java
 Dictionary Meaning: Exception is an abnormal
condition.
 The Exception Handling in Java is one of the

powerful mechanism to handle the runtime errors so
that normal flow of the application can be maintained.
 Exception Handling is a mechanism to handle

runtime errors such as ClassNotFoundException,
IOException, SQLException, RemoteException, etc.
Advantage of Exception Handling
 The core advantage of exception handling is to maintain
the normal flow of the application. An exception
normally disrupts the normal flow of the application that is
why we use exception handling. Let's take a example:
• statement 1;
• statement 2;
• statement 3;
• statement 4;
• statement 5;//exception occurs Suppose there are 10 statements in your
• statement 6; program and there occurs an exception at
• statement 7; statement 5, the rest of the code will not
be executed i.e. statement 6 to 10 will not
• statement 8; be executed. If we perform exception
• statement 9; handling, the rest of the statement will be
• statement 10; executed. That is why we use exception
handling in Java.
Types of Java Exceptions
There are mainly two types of exceptions: checked and unchecked.
An error is considered as the unchecked exception.
There are three types of exceptions:

Difference between Checked and Unchecked
Exceptions
1) Checked Exception
The classes which directly inherit 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 which inherit RuntimeException are known as unchecked
exceptions e.g. ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException etc. Unchecked exceptions are not
checked at compile-time, but they are checked at runtime.
3) Error
Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError,
AssertionError etc.
Java Exception Keywords
There are 5 keywords which are used in handling exceptions in Java.
Java Exception Handling Example
public class JavaExceptionExample{
public static void main(String args[]){
try{
//code that may raise exception
int data=100/0;
}catch(ArithmeticException e){System.out.println(e);}
//rest code of the program
System.out.println("rest of the code...");
}
}
Output:
Exception in thread main java.lang.ArithmeticException:/ by
zero rest of the code...
In the above example, 100/0 raises an ArithmeticException which is

handled by a try-catch block.
Common Scenarios of Java Exceptions
There are given some scenarios where unchecked exceptions may occur.
They are as follows:
1) A scenario where ArithmeticException occurs

If we divide any number by zero, there occurs an ArithmeticException.
int a=50/0;//ArithmeticException
2) A scenario where NullPointerException occurs
If we have a null value in any variable, performing any operation on the
variable throws a NullPointerException.
String s=null;
System.out.println(s.length());//NullPointerException
Common Scenarios of Java Exceptions
3) A scenario where NumberFormatException occurs
The wrong formatting of any value may occur NumberFormatException.
Suppose I have a string variable that has characters, converting this
variable into digit will occur NumberFormatException.
String s="abc";
int i=Integer.parseInt(s);//NumberFormatException
4) A scenario where ArrayIndexOutOfBoundsException occurs

If you are inserting any value in the wrong index, it would result in
ArrayIndexOutOfBoundsException as shown below:
int a[]=new int[5];

a[10]=50; //ArrayIndexOutOfBoundsException
Java try block
Java try block is used to enclose the code that might throw an
exception. It must be used within the method.
If an exception occurs at the particular statement of try block, the
rest of the block code will not execute. So, it is recommended not to
keeping the code in try block that will not throw an exception.
Java try block must be followed by either catch or finally block.
Syntax of Java try-catch
try{
//code that may throw an exception
}catch(Exception_class_Name ref){}
Syntax of try-finally block

try{
//code that may throw an exception
}finally{}
Java catch block
Java catch block is used to handle the Exception by declaring the type
of exception within the parameter. The declared exception must be the
parent class exception ( i.e., Exception) or the generated exception
type. However, the good approach is to declare the generated type of
exception.
The catch block must be used after the try block only. You can use
multiple catch block with a single try block.
Problem without exception handling
Let's try to understand the problem if we don't use a try-catch block.
Example 1
public class TryCatchExample1 {
public static void main(String[] args) {
int data=50/0; //may throw exception
System.out.println("rest of the code");
} Output:
Exception in thread "main" java.lang.ArithmeticException: / by zero
As displayed in the above example, the rest of the code is not executed (in such
case, the rest of the code statement is not printed).
There can be 100 lines of code after exception. So all the code after exception will
not be executed.
Solution by exception handling
Let's see the solution of the above problem by a java try-catch block.
Example 2
public class TryCatchExample2 {

try
{
int data=50/0; //may throw exception
}
//handling the exception
catch(ArithmeticException e)
{
System.out.println(e);
}
}
} Output:
java.lang.ArithmeticException: / by zero rest of the code
Now, as displayed in the above example, the rest of the code is executed,
i.e., the rest of the code statement is printed.
Java catch multiple exceptions
public class MultipleCatchBlock1 {
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Exception occurs");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("ArrayIndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Parent Exception occurs");
}
}
}
Java finally block
Java 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.
public class TestFinallyBlock2{
try{
int data=25/0;
System.out.println(data);
}
catch(ArithmeticException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");
}
}
}
Output:
Exception in thread main java.lang.ArithmeticException:/ by zero

finally block is always executed
rest of the code ...
java throw keyword example
In this example, we have created the validate method that takes integer
value as a parameter. If the age is less than 18, we are throwing the
ArithmeticException otherwise print a message welcome to vote.
public class TestThrow1{

static void validate(int age){
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome ……….");
}
validate(13);
}
}
Output:
Exception in thread main java.lang.ArithmeticException:not valid
Java throws keyword
The Java throws keyword is used to declare an exception. It gives

an information to the programmer that there may occur an exception
so it is better for the programmer to provide the exception handling
code so that normal flow can be maintained.
Exception Handling is mainly used to handle the checked exceptions. If
there occurs any unchecked exception such as NullPointerException, it
is programmers fault that he is not performing check up before the
code being used.
Syntax of java throws

return_type method_name() throws exception_class_name{
//method code
}
Java throws example
import java.io.IOException;
class Testthrows1{
void m()throws IOException{
throw new IOException("device error");//checked exception
}
void n()throws IOException{
m();
}
void p(){
try{
n();
}catch(Exception e){System.out.println("exception handled");}
}
Testthrows1 obj=new Testthrows1();
obj.p();
System.out.println("normal flow...");
} Output:
} exception handled
normal flow...

Exception Handling in Java

Uploaded by

Copyright:

Available Formats

Exception Handling in Java

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Exception Handling in Java

Uploaded by

Copyright:

Available Formats

 Exception in Java

Dr. Turkan Ahmed Khalee

 The Exception Handling in Java is one of the

 Exception Handling is a mechanism to handle

There are three types of exceptions:

In the above example, 100/0 raises an ArithmeticException which is

1) A scenario where ArithmeticException occurs

4) A scenario where ArrayIndexOutOfBoundsException occurs

int a[]=new int[5];

Syntax of try-finally block

public static void main(String[] args) {

int data=50/0; //may throw exception

System.out.println("rest of the code");

public static void main(String[] args) {

Exception in thread main java.lang.ArithmeticException:/ by zero

public class TestThrow1{

The Java throws keyword is used to declare an exception. It gives

Syntax of java throws

You might also like