What Is an Exception?

The term exception is shorthand for the phrase

"exceptional event."

Definition: An exception is an event, which occurs

during the execution of a program, that disrupts the
normal flow of the program's instructions.

When an error occurs within a method, the method

creates an object and hands it off to the runtime
system. The object, called an exception object, contains
information about the error, including its type and
the state of the program when the error occurred.
Creating an exception object and handing it to the
runtime system is called throwing an exception.
After a method throws an exception, the runtime
system attempts to find something to handle it. The
set of possible "somethings" to handle the exception
is the ordered list of methods that had been called to
get to the method where the error occurred. The list
of methods is known as the call stack (see the next
figure).
 The call stack.
The runtime system searches the call stack for a
method that contains a block of code that can handle
the exception. This block of code is called
an exception handler. The search begins with the
method in which the error occurred and proceeds
through the call stack in the reverse order in which
the methods were called. When an appropriate
handler is found, the runtime system passes the
exception to the handler. An exception handler is
considered appropriate if the type of the exception
object thrown matches the type that can be handled
by the handler.
The exception handler chosen is said to catch the
exception. If the runtime system exhaustively
searches all the methods on the call stack without
finding an appropriate exception handler, as shown
in the next figure, the runtime system (and,
consequently, the program) terminates.

Searching the call stack for the exception handler.

Using exceptions to manage errors has some
advantages over traditional error-management
techniques. You can learn more in the Advantages of
Exceptions section.
Exception Handling in Java
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.
 In this page, we will learn about java exception, its
type and the difference between checked and
unchecked exceptions.
What is exception
Dictionary Meaning: Exception is an abnormal
condition.
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.
Advantage of Exception Handling
The core advantage of exception handling is to
maintain the normal flow of the application.
Exception normally disrupts the normal flow of the
application that is why we use exception handling.
Let's take a scenario:
1. statement 1;  
2. statement 2;  
3. statement 3;  
4. statement 4;  
5. statement 5;//exception occurs  
6. statement 6;  
7. statement 7;  
8. statement 8;  
9. statement 9;  
10. statement 10;  
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.
Hierarchy of Java Exception classes
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:
1. Checked Exception
2. Unchecked Exception
3. 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.

Common scenarios where exceptions may occur

There are given some scenarios where unchecked
exceptions can occur. They are as follows:
1) Scenario where ArithmeticException occurs
If we divide any number by zero, there occurs an
ArithmeticException.
1. int a=50/0;//ArithmeticException  

2) Scenario where NullPointerException occurs

If we have null value in any variable, performing
any operation by the variable occurs an
NullPointerException.
1. String s=null;  
2. System.out.println(s.length());//NullPointerExc
eption  
 3) Scenario where NumberFormatException occurs
The wrong formatting of any value, may occur
NumberFormatException. Suppose I have a string
variable that have characters, converting this
variable into digit will occur
NumberFormatException.
1. String s="abc";  
2. int i=Integer.parseInt(s);//NumberFormatExce
ption  

4) Scenario where
ArrayIndexOutOfBoundsException occurs
If you are inserting any value in the wrong index, it
would result ArrayIndexOutOfBoundsException as
shown below:
1. int a[]=new int[5];  
2. a[10]=50; //ArrayIndexOutOfBoundsException  

Java Exception Handling Keywords

There are 5 keywords used in java exception
handling.
1. try
2. catch
3. finally
4. throw
 5. throws
For example, if you use FileReader class in your
program to read data from a file, if the file specified
in its constructor doesn't exist, then
a FileNotFoundException occurs, and the compiler
prompts the programmer to handle the exception.
Example
import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

public static void main(String args[]) {

File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}
If you try to compile the above program, you will
get the following exceptions.
Output
C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported
exception FileNotFoundException; must be caught
or declared to be thrown
FileReader fr = new FileReader(file);
^
1 error
Note − Since the methods read() and close() of
FileReader class throws IOException, you can
observe that the compiler notifies to handle
IOException, along with FileNotFoundException.
 Unchecked exceptions − An unchecked
exception is an exception that occurs at the time
of execution. These are also called as Runtime
Exceptions. These include programming bugs,
such as logic errors or improper use of an API.
Runtime exceptions are ignored at the time of
compilation.
For example, if you have declared an array of size 5
in your program, and trying to call the 6th element
of the array then
an ArrayIndexOutOfBoundsExceptionexception occurs.
Example
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 the following exception.
Output
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 5
at
Exceptions.Unchecked_Demo.main(Unchecked_De
mo.java:8)
 Errors − These are not exceptions at all, but
problems that arise beyond the control of the
user or the programmer. Errors are typically
ignored in your code because you can rarely do
anything about an error. For example, if a stack
overflow occurs, an error will arise. They are
also ignored at the time of compilation.
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
}
The previous statements demonstrate three catch
blocks, but you can have any number of them after
a single try. If an exception occurs in the protected
code, the exception is thrown to the first catch block
in the list. If the data type of the exception thrown
matches ExceptionType1, it gets caught there. If not,
the exception passes down to the second catch
statement. This continues until the exception either
is caught or falls through all catches, in which case
the current method stops execution and the
exception is thrown down to the previous method
on the call stack.
Example
Here is code segment showing how to use multiple
try/catch statements.

try {
 file = new FileInputStream(fileName);
x = (byte) file.read();
}catch(IOException i) {
i.printStackTrace();
return -1;
}catch(FileNotFoundException f) // Not valid! {
f.printStackTrace();
return -1;
}
Catching Multiple Type of Exceptions
Since Java 7, you can handle more than one
exception using a single catch block, this feature
simplifies the code. Here is how you would do it −

catch (IOException|FileNotFoundException ex) {

logger.log(ex);
throw ex;
The Throws/Throw Keywords
If a method does not handle a checked exception,
the method must declare it using
the throws keyword. The throws keyword appears
at the end of a method's signature.
You can throw an exception, either a newly
instantiated one or an exception that you just
caught, by using the throw keyword.
Try to understand the difference between throws
and throw keywords, throws is used to postpone the
handling of a checked exception and throw is used
to invoke an exception explicitly.
The following method declares that it throws a
RemoteException −
Example
import java.io.*;
public class className {

public void deposit(double amount) throws

RemoteException {
// Method implementation
throw new RemoteException();
}
// Remainder of class definition
}
A method can declare that it throws more than one
exception, in which case the exceptions are declared
in a list separated by commas. For example, the
following method declares that it throws a
RemoteException and an
InsufficientFundsException −
Example
import java.io.*;
public class className {

public void withdraw(double amount) throws

RemoteException,
InsufficientFundsException {
// Method implementation
}
// Remainder of class definition
}
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 catch
blocks and has the following syntax −
Syntax
try {
// Protected code
}catch(ExceptionType1 e1) {
// Catch block
}catch(ExceptionType2 e2) {
// Catch block
}catch(ExceptionType3 e3) {
// Catch block
}finally {
// The finally block always executes.
}
Example
public class ExcepTest {

public static void main(String args[]) {

int a[] = new int[2];
try {
System.out.println("Access element three :" +
a[3]);
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}finally {
a[0] = 6;
 System.out.println("First element value: " +
a[0]);
System.out.println("The finally statement is
executed");
}
}
}
This will produce the following result −
Output
Exception thrown
:java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed
Note the following −
 A catch clause cannot exist without a try
statement.
 It is not compulsory to have finally clauses
whenever a try/catch block is present.
 The try block cannot be present without either
catch clause or finally clause.
 Any code cannot be present in between the try,
catch, finally blocks.
The try-with-resources
Generally, when we use any resources like streams,
connections, etc. we have to close them explicitly
using finally block. In the following program, we
are reading data from a file using FileReader and
we are closing it using finally block.
Example
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

public static void main(String args[]) {

FileReader fr = null;
try {
File file = new File("file.txt");
fr = new FileReader(file); char [] a = new
char[50];
fr.read(a); // reads the content to the array
for(char c : a)
System.out.print(c); // prints the characters
one by one
 }catch(IOException e) {
e.printStackTrace();
}finally {
try {
fr.close();
}catch(IOException ex) {
ex.printStackTrace();
}
}
}
}
try-with-resources, also referred as automatic
resource management, is a new exception handling
mechanism that was introduced in Java 7, which
automatically closes the resources used within the
try catch block.
To use this statement, you simply need to declare
the required resources within the parenthesis, and
the created resource will be closed automatically at
the end of the block. Following is the syntax of try-
with-resources statement.
Syntax
try(FileReader fr = new FileReader("file path")) {
 // use the resource
}catch() {
// body of catch
}
}
Following is the program that reads the data in a
file using try-with-resources statement.
Example
import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

public static void main(String args[]) {

try(FileReader fr = new
FileReader("E://file.txt")) {
char [] a = new char[50];
fr.read(a); // reads the contentto the array
for(char c : a)
System.out.print(c); // prints the characters
one by one
}catch(IOException e) {
e.printStackTrace();
 }
}
}
Following points are to be kept in mind while
working with try-with-resources statement.
 To use a class with try-with-resources statement
it should implement AutoCloseable interface
and the close() method of it gets invoked
automatically at runtime.
 You can declare more than one class in try-with-
resources statement.
 While you declare multiple classes in the try
block of try-with-resources statement these
classes are closed in reverse order.
 Except the declaration of resources within the
parenthesis everything is the same as normal
try/catch block of a try block.
 The resource declared in try gets instantiated
just before the start of the try-block.
 The resource declared at the try block is
implicitly declared as final.
User-defined Exceptions
You can create your own exceptions in Java. Keep
the following points in mind when writing your
own exception classes −
  All exceptions must be a child of Throwable.
 If you want to write a checked exception that is
automatically enforced by the Handle or
Declare Rule, you need to extend the Exception
class.
 If you want to write a runtime exception, you
need to extend the RuntimeException class.
We can define our own Exception class as below −

class MyException extends Exception {

}
You just need to extend the
predefined Exception class to create your own
Exception. These are considered to be checked
exceptions. The
following InsufficientFundsException class is a
user-defined exception that extends the Exception
class, making it a checked exception. An exception
class is like any other class, containing useful fields
and methods.
Example
// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends

Exception {
 private double amount;

public InsufficientFundsException(double
amount) {
this.amount = amount;
}

public double getAmount() {

return amount;
}
}
To demonstrate using our user-defined exception,
the following CheckingAccount class contains a
withdraw() method that throws an
InsufficientFundsException.

// File Name CheckingAccount.java

import java.io.*;

public class CheckingAccount {

private double balance;
private int number;

public CheckingAccount(int number) {

 this.number = number;
}

public void deposit(double amount) {

balance += amount;
}

public void withdraw(double amount) throws

InsufficientFundsException {
if(amount <= balance) {
balance -= amount;
}else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}

public double getBalance() {

return balance;
}

public int getNumber() {

return number;
 }
}
The following BankDemo program demonstrates
invoking the deposit() and withdraw() methods of
CheckingAccount.

// File Name BankDemo.java

public class BankDemo {

public static void main(String [] args) {

CheckingAccount c = new
CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);

try {
System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600...");
c.withdraw(600.00);
}catch(InsufficientFundsException e) {
System.out.println("Sorry, but you are short $"
+ e.getAmount());
 e.printStackTrace();
}
}
}
Compile all the above three files and run
BankDemo. This will produce the following result −
Output
Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
at
CheckingAccount.withdraw(CheckingAccount.java:
25)
at BankDemo.main(BankDemo.java:13)
Common Exceptions
In Java, it is possible to define two catergories of
Exceptions and Errors.
 JVM Exceptions − These are exceptions/errors
that are exclusively or logically thrown by the
JVM. Examples: NullPointerException,
 ArrayIndexOutOfBoundsException,
ClassCastException.
 Programmatic Exceptions − These exceptions
are thrown explicitly by the application or the
API programmers. Examples:
IllegalArgumentException,
IllegalStateException.