Exception handling
Lecture - 30
Did you notice the
gaps between two
rail tracks???
In
If summer,
there is no
duegapto
Why??? Thermal
heat,
between
iron the
will
Expansion
tracks,expand
it will bend
Accidents!!!
Result???
So, We have to rectify That’s why we are
that accidents having gaps between
the rail tracks
An exception is
handled here
Similarly in Java
How to handle
also we may get
it?????
problems
Exception
Abnormal condition
or not coming under
any rule
Exception in Java
• In Java, an exception is an event that disrupts the normal flow of the
program.
• It is an object which is thrown at runtime.
Exception Handling in Java
• Exception Handling is a mechanism to handle runtime errors
• Runtime errors
• ClassNotFoundException,
• IOException,
• SQLException,
• RemoteException, etc.
Compile time error run time error
What is the difference???
public class Test
{
public static void main(String a[])
{
Compile time error
System.out.println("Hello")
}
}
Error:
Output : ?????
C:\Sample>Javac Test.java
Syntax Errors Test.java:3: error: ';' expected
System.out.println("Hello")
public class Test
{
public static void main(String a[])
{
Run time error int arr[]=new int[5];
arr[10]=20;
}
}
Error:
Output
Exception in thread : ?????
"main"
logical Errors java.lang.ArrayIndexOutOfBoundsException: 10
at Test.main(Test.java:6)
Syntax Errors Errors
logical Errors Exceptions
We have to clear the
Errors error
Can not
by following
be handled
the
syntax
Exceptions Can be handled
Types of Java Exceptions
Exceptions
Checked Unchecked
Exceptions Exceptions
Checked Exception
• The classes which directly inherit Throwable class except
RuntimeException and Error are known as checked exceptions
• Example
• IOException,
• SQLException etc.
• Checked exceptions are checked at compile-time.
Unchecked Exception
• The classes which inherit RuntimeException are known as unchecked
exceptions
• Example
• ArithmeticException,
• NullPointerException,
• ArrayIndexOutOfBoundsException etc.
• Unchecked exceptions are not checked at compile-time, but they are
checked at runtime.
Common Scenarios of Java Exceptions
ArithmeticException
int a=50/0;
Common Scenarios of Java Exceptions
NullPointerException
String s=null;
System.out.println(s.length());
Common Scenarios of Java Exceptions
NumberFormatException
String s="abc";
int i=Integer.parseInt(s);
Common Scenarios of Java Exceptions
ArrayIndexOutOfBoundsException
int a[]=new int[5];
a[10]=50;
Java Exception Keywords
try
catch
finally
throw
throws
try
The "try" keyword is used to specify a block
where we should place exception code
The try block must be followed by either
catch or finally
catch
The "catch" block is used to handle the
exception.
It must be preceded by try block which
means we can't use catch block alone
It can be followed by finally block later
finally
The "finally" block is used to execute the
important code of the program
It is executed when an exception is handled
or not.
throw
The "throw" keyword is used to throw an
exception
throws
The "throws" keyword is used to declare
exceptions, it doesn't throw an exception
It specifies that there may occur an
exception in the method.
Java Exception Handling Example
import java.util.*; catch(ArithmeticException e)
public class Test {
{ System.out.println(e);
public static void main(String args[]) }
{ System.out.print(i+" ");
Scanner s=new Scanner(System.in);
int n=s.nextInt(); }
catch block to catch
for(int i=0; i<=n; i++) }
the exception if
{ }
occurred
try
{
Calculation in try Output:
int data=100/i; java.lang.ArithmeticException: / by zero
block 0 1 2 3 4 5 6 7 8 9 10
}
Program with multiple catch
import java.util.*; catch(ArithmeticException e)
public class Test {
{ System.out.println(e);
public static void main(String args[]) }
{ catch(ArrayIndexOutOfBoundsException e)
Scanner s=new Scanner(System.in); {
int n=s.nextInt(); System.out.println(e);
int arr[]=new int[3]; }
for(int i=0;i<=n;i++) }
{ }
try } Output:
{ java.lang.ArithmeticException: / by zero
int data=100/i; java.lang.ArrayIndexOutOfBoundsException: 3
arr[i]=data;
java.lang.ArrayIndexOutOfBoundsException: 4
java.lang.ArrayIndexOutOfBoundsException: 5
}
Java finally block
• Java finally block is always executed whether exception is handled or
not.
• Java finally block follows try or catch block.
Java finally block
Java finally block- example
import java.util.*; count++;
public class Test System.out.println(e);
{ }
public static void main(String args[]) finally
{ {
Scanner s=new Scanner(System.in); if(i==n)
double data; {
int count=0, n=s.nextInt(); if(count==0 )
for(int i=0;i<=n;i++) System.out.println("No exception ");
{ else
try System.out.println(count +" exception handled");
{ }
data=100/i; }
System.out.println(data+ " "); }
} }
catch(ArithmeticException e) }
{
Output:
java.lang.ArithmeticException: / by zero
100.0
50.0
33.0
25.0
20.0
16.0
14.0
12.0
11.0
10.0
1 exception handled
Java throw keyword
throw
used to explicitly throw an
exception
can throw either checked or
unchecked exception
Java throw block- example
import java.util.*;
public class Test
static void validate(int age)
if(age<18)
throw new ArithmeticException("Under Age");
else
System.out.println("welcome to vote");
}
Output:
public static void main(String args[])
Exception in thread "main"
{
java.lang.ArithmeticException: Under Age
Scanner s=new Scanner(System.in);
at Test.validate(Test.java:7)
int n=s.nextInt();
at Test.main(Test.java:15)
validate(n);
Command exited with non-zero status 1
}
}
Till now we discussed about
What if a checked
how to deal with unchecked throws
exception occurs???
exceptions
throws keyword
throws
used to declare an exception
It gives an information to the
programmer that there may
occur an exception
throws keyword
Syntax
return_type method_name() throws exception_class_name
{
//method code
}
throws keyword
Example
void method()throws IOException
{
//method code
}
throws keyword example
import java.io.*; M m=new M();
class M m.method();
{ }
void method()throws IOException }
{
throw new IOException("device error");
public class Test Output:
{ Exception in thread "main"
java.io.IOException:device error
public static void main(String args[])throws
IOException
at M.method(Test.java:6)
at Test.main(Test.java:14)
{
Command exited with non-zero status 1
Difference between throw and throws
