Lecture – 13

Exceptions Handling in Java

Afsara Tasneem Misha

Lecturer
Department of CSE
Daffodil International University
 Contents

• Java – Exceptions Handling

2
Exceptions Handling
 Difference between Error and Exception
Errors:
• Indicate serious problems and abnormal conditions that most applications should not try to handle.
• Error defines problems that are not expected to be caught under normal circumstances by our program.

• For example:
memory error, hardware error, JVM error etc.

• Errors are typically ignored in code because you can rarely do anything about an error.
• Example: if stack overflow occurs, an error will arise. This type of error is not possible handle in code.

Exceptions:
• Exception is an abnormal condition.
• An exception (or exceptional event) is a problem that arises during the execution of a program.
• In java, exception is an event that disrupts the normal flow of the program.
• It is an object which is thrown at runtime.
 What is exception handling?

• Exception Handling is a mechanism to handle runtime errors

such as:
ClassNotFound, IO, SQL, Remote etc.
 Java – Exceptions
An exception can occur for many different reasons, below given are
some scenarios where exception occurs.

• A user has entered invalid data.

• A file that needs to be opened cannot be found.
• A network connection has been lost in the middle of communications or the
JVM has run out of memory.

Some of these exceptions are caused by user error, others by programmer

error, and others by physical resources that have failed in some manner.
Advantage of Exception Handling
The core advantage of exception handling
is to maintain the normal flow of the
application.
Let's take a scenario:
Suppose there is 10 statements in your
program and there occurs an exception at
statement 5, rest of the code will not be
executed i.e. statement 6 to 10 will not run.
If we perform exception handling, rest of the
statement will be executed. That is why we
use exception handling in java.
 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
1. Checked exceptions
• All exceptions other than Runtime Exceptions are known as Checked
exceptions as the compiler checks them during compilation

• A checked exception is an exception that occurs at the compile time,

these are also called as compile time exceptions.

• These exceptions cannot simply be ignored at the time of compilation

Examples of Checked Exceptions :
Some checked exceptions are as follows:

• ClassNotFoundException

• IllegalAccessException

• NotSuchFieldException

• EOFExceptionException
2. Unchecked Exceptions
• Runtime Exceptions are also known as Unchecked Exceptions as the
compiler do not check whether the programmer has handled them or
not

• These exceptions need not be included in any method’s throws list

because compiler does not check to see if a method handles or
throws these exceptions.
Examples of Unchecked Exceptions :
Some unchecked exceptions are as follows:

• ArithmaticException

• ArrayIndexOutOfBoundException

• NullPointerException

• NegativeArraySizeException
Hierarchy of Java Exception classes
Exception classes
 Difference between checked and unchecked
exceptions

• 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.
• 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.
• Error
Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError
etc.
Common scenarios where exceptions may occur
1. Scenario where ArithmeticException occurs

If we divide any number by zero, there occurs an ArithmeticException.

2. Scenario where NullPointerException occurs

NullPointerException
Common scenarios where exceptions may occur

3. Scenario where NumberFormatException occurs

4. Scenario where ArrayIndexOutOfBoundsException occurs

Example: ArrayIndexOutOfBoundsException

public class Unchecked_Demo {

public static void main(String args[]){

int num[]={1,2,3,4};
System.out.println(num[5]);
}
}

If you compile and execute the above program you will get exception as shown below.

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

 Java Exception Handling Keywords

There are 5 keywords used in java exception handling.

• try
• catch
• finally
• throw
• throws
 try catch in java
Syntax of try catch in java
Problem without exception handling

• Let's try to understand the problem if we don't use try-catch block.

public class Testtrycatch1{

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
Solution by exception handling
• Let's see the solution of above problem by java try-catch block.

public class Testtrycatch2{

public static void main(String args[]){

try{
int data=50/0;
}

catch (ArithmeticException e)
{
System.out.println(e);
}

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

}
}

• Output:
Exception in thread main java.lang.ArithmeticException:/ by zero
Flow of control in try/catch blocks:
* When exception doesn’t occur
int x = 10;
int y = 10;
try {
int num= x/y;
System.out.println("next-statement: Inside try block");
}
catch (Exception ex)
{
System.out.println("Exception");
}
System.out.println("next-statement: Outside of try-catch");

• Output:
next-statement: Inside try block
next-statement: Outside of try-catch
• In the above example exception didn’t occur in try block so catch block didn’t run.
Flow of control in try/catch blocks:
* When exception occurs
int x = 10;
int y = 0;
try {
int num= x/y;
System.out.println("next-statement: Inside try block");
}
catch (Exception ex)
{
System.out.println("Exception Occured");
}
System.out.println("next-statement: Outside of try-catch");
• Output:
Exception Occurred
next-statement: Outside of try-catch
• Point to note in above example: There are two statements present inside try block. Since exception occurred
because of first statement, the second statement didn’t execute. Hence we can conclude that if an exception
occurs then the rest of the try block doesn’t execute and control passes to catch block.
Multiple catch blocks
• try
{
//Protected code
}

• catch(ExceptionType1 e1)
{
//Catch block
}

• catch(ExceptionType2 e2)
{
//Catch block
}

• catch(ExceptionType3 e3) • Output:

{
//Catch block
Array Index Out Of Bounds Exception
}
 The finally block

• The finally block follows a try block or a catch block.

• A finally block of code always executes, irrespective of occurrence of
an Exception.
• Using a finally block allows you to run any cleanup-type statements
that you want to execute, no matter what happens in the protected
code.
A finally block appears at the end of the try blocks and has the
following syntax:

try
{
//statements that may cause an exception
}
finally
{
//statements to be executed
}
A finally block appears at the end of the catch blocks and has the following
syntax:

try
{
//Protected code
}
catch(ExceptionType1 e1)
{
//Catch block
}
finally
{
//The finally block always executes.
}
 Java throw keyword

• The Java throw keyword is used to explicitly throw an exception.

• Syntax of throw keyword:

throw new exception_class("error message");

throw keyword example
Java throws keyword

SELF STUDY
Questions?
• What is the difference between checked and unchecked exceptions ?
• What happens behind the code int data=50/0; ?
• Why use multiple catch block ?
• Is there any possibility when finally block is not executed ?
• What is exception propagation ?
• What is the difference between throw and throws keyword ?
• What are the 4 rules for using exception handling with method
overriding ?
Thank You