Exception handling

Exception handling
st-1
st-2
st-3 exception raised
st-4
In application whenever the exception occurred,

1. Program terminated abnormally.
2. Rest of the application is not executed.
There are two ways to handle the excpetion,

a. try-catch
b. throws
once we handle the exception

1. Program terminated normally.
2. Rest of the application is executed.
Note : The main objective of exception handling is to get the normal termination of
the applicaion.
Types of Exceptions: As per the sun micro systems standards The Exceptions are
divided into three types
1. Checked Exception
2. Unchecked Exception
3. Error
Unchecked Exception:
a. The Unchecked Exception are caused due to end user inputproblems.
b. The exceptions are not checked by compiler are called Unchecked
Exception
ex : AE, AIOBE , NPE , NFE...etc
c. These are child class of RuntimeException.
class Test {
public static void main(String[] args) {
System.out.println("ratan");
//System.out.println(10/0); //AE
int[] a = {10,20,30};
//System.out.println(a[6]);
java.lang.ArrayIndexOutOfBoundsException:
//System.out.println("ratan".charAt(12));
StringIndexOutOfBoundsException
//int[] arr = new int[-6];

java.lang.NegativeArraySizeException
System.out.println("rest of the application");

}
}
Checked Exception:
a. the checked exceptions are caused due to developer issues.
b. The Exceptions which are checked by the compiler are called Checked Exceptions.
IOException,SQLException,InterruptedException ……..etc
c. these are child class of Exception.
import java.io.*;
class Test
{ public static void main(String[] args)throws
InterruptedException,FileNotFoundException
{ System.out.println("ratan");
//Thread.sleep(1000);
FileInputStream fis = new FileInputStream("abc.txt");
System.out.println("rest of the application...");

}
}
Note: Whether it is a checked Exception or unchecked exception exceptions are

raised at runtime but not compile time.
Note :The checked exceptions are safe because the compiler will give some
information about the exception at compile time itself.
//errors :
The exception are occurred due to two reasons
a. Developer mistakes
b. End-user input mistakes.
c. network Connections.
But errors are caused due to lack of system resources.
StackOverFlowError, OutOfMemoryError …………etc
It is possible to handle the exceptions by using try-catch blocks or throws keyword

but it is not possible to handle the errors.
class Test
{ public static void main(String[] args)
{ int[] a = new int[1000000000];
}
}
java.lang.OutOfMemoryError: Java heap space
Error is an un-checked type exception.
Exception handling keywords:

1. try
2. catch
3. finally
4. throws
5. throw
There are two ways to handle the exceptions in java.

1) By using try-catch block.
2) By using throws keyword
Exception handling by using try–catch blocks:
Syntax:
try
{ exceptional code : it may or may not raise an exception
}
catch (Exception_Name reference_variable)
{ logics run if an exception raised in try block.
}
ex-1: Whenever the exception raised in the try block, the corresponding catch
block executed.
Application without try-catch blocks

class Test
System.out.println(10/0);
}
}
E:\>java Test
ratan
Exception : ArithmeticException: / by zero
Disadvantages:
1. program terminated abnormally.
2. rest of the application not executed.
Application with try-catch blocks:

class Test
try {
}
catch (ArithmeticException ae)
{ System.out.println(10/2);
}
}
}
E:\>java Test
ratan
5
Rest of the application
Advantages:
1. Program terminated normally
2. Rest of the application executed
ex-2 : In below example catch block is not matched hence program is terminated
abnormally.
try
{ System.out.println("sravya");
}
catch(NullPointerException e)
}
ex 3: If there is no exception in try block the corresponding catch blocks are

not executed.
class Test
{ try
}
catch(NullPointerException e)
}
System.out.println("rest of the app");
}
}
E:\sravya>java Test
sravya
rest of the app
ex - 4: In Exception handling independent try block declaration is not allowed.
class Test
{ try
}
}
}
E:\sravya>javac Test.java
Test.java:4: 'try' without 'catch' or 'finally' or resources
ex- 5: In between try-catch blocks it is not possible to declare any statements.

try
}
System.out.println("anu");
catch(ArithmeticException e)
}
ex 6:
If the exception raised in other than try block it is always abnormal termination.
In below example exception raised in catch block hence program is terminated
abnormally.
try
}
}
ex- 7:
If the exception raised in try block the remaining code of try block is not
executed.
Once the control is out of the try block the control never entered into try block
once again.
Don’t take normal code inside try block because no guarantee all statements in try-
block will be executed or not.
class Test
{ try{
System.out.println("durga");
}
}
}
}
E:\sravya>java Test
Durga
ratan
5
rest of the app
class Test
{ try{
System.out.println("durga");
}
}
}
}
E:\sravya>java Test
5
rest of the app
Day-2 Exception Handling
Category-1 : try with multiple catch blocks

case 1 :
import java.util.Scanner;
class Test
{ Scanner s = new Scanner(System.in);
System.out.println("enter the division value");
int num = s.nextInt();
try
{ System.out.println(10/num);
System.out.println("ratan".charAt(10));
}
{ System.out.println("Ratanit");
}
catch(StringIndexOutOfBoundsException e)
{ System.out.println("nareshit");
}
System.out.println("Rest of the application....");
}
}
case-2: lazy
class Test
try
}
catch (Exception e)
{ System.out.println("Ratanit..."+e);
}
}
}
case 3:
class Test
try
}
//child to parent
}
catch(Exception e)
}
}
}
case 4: Parent to child :

//parent to child
catch(Exception e)
}
}
in above case the parent can handle all exceptions then no use of child.
error: exception ArithmeticException has already been caught
Category-2 pipe symbol java 7v
The catch block can handle the multiple exceptions using pipe symbol.
case 1: unchecked
catch(ArithmeticException | ClassCastException a)
catch(NumberFormatException|NullPointerException|StringIndexOutOfBoundsException a)
case 2: checked
catch(FileNotFoundException|InterruptedException a)
case 3: mixing of both checked & uncheked

catch(FileNotFoundException| ArithmeticException a)
case 4: Invalid : not possible to take both parent & child

catch(Exception | ArithmeticException a)
Category-3 try-with resources java 7
case 1: Declare the resource using try block, once the try block is completed the
resource is automatically released.
how it releases automatically means, it internally uses AutoCloseable.
void close() throws Exception
Closes this resource, relinquishing any underlying resources. This method is
invoked automatically on objects managed by the try-with-resources statement.
class Test
{ try(Scanner s = new Scanner(System.in))
{ System.out.println("enter id");
int a = s.nextInt();
System.out.println("input value="+a);
}
}
}
if the resource is not throwing an exception, so catch block not required.
case 2:
import java.io.*;
class Test
{ try(FileInputStream fis = new FileInputStream("abc.txt"))
{ System.out.println("reading data from text file");
}
catch(IOException e)
{ System.out.println("Exceptio raised....");
}
}
}
if the resource is throwing an exception, so catch block required.
FileNotFoundException: reading the data from the file
IOException: exception thrown from implicit call to close().
FileNotFoundException is a child class of IOException, so taking catch block of the

parent class is good.
case 3:By using try block it is possible to declare more than one resource but
every resource is separated with a semicolon.
try(Scanner s = new Scanner(System.in);
FileInputStream fis = new FileInputStream("abc.txt"))
{ //some code here
}
in multiple resources, if at least one resource throws an exception then catch is
mandatory.
Category-4 printing Exception information
case 1:The developer can print the exceptions msg in three ways,
1) toString()
2) getMessage()
3) printStackTrace()
class Test
{ void m3()
{ try{ System.out.println(10/0); }
catch(ArithmeticException ae)
{ System.out.println(ae.toString());
System.out.println(ae.getMessage());
ae.printStackTrace();
}
}
void m2()
{ m3();
}
void m1()
{ m2();
}
public static void main(String[] args)
{ new Test().m1();
}
}
E:\>java Test
java.lang.ArithmeticException: / by zero
/ by zero
java.lang.ArithmeticException: / by zero
at Test.m3(Test.java:3)
at Test.main(Test.java:18)
case 2: if we are not handled exception so The JVM Internally uses

printStackTrace() method to print exception information.
case 3: Exception Propagation.

class Test
{ void m3()
}
void m2()
{ m3();
}
void m1()
{ try{m2();}
catch(ArithmeticException ae){System.out.println("Exception
handled...");}
}
{ new Test().m1();
}
}
In above example the exception raised in m3() method but it is not handled so it
is propagated to m2() method.
Here the m2() method is not handled exception so it is propagated to m1().
In above example m1() is handled exception.
Note: only the unchecked Exceptions are propagated automatically but not checked.
Category-5 nested try-catch

case 1:
try{
}
catch (){
}
case 2:
try{
}
catch (){
}
fsdfsdf
sdfsdfsdf
try{
}
catch (){
}
case 3:
try{
}
catch (){
}
catch (){
}
case 4:
try
{ try
{
}
catch ()
{
}
}
catch ()
{
}
case 5:
try
{
}
catch ()
{ try
{
}
catch ()
{
}
}
case 6:
try
{ try
{
}
catch ()
{
}
}
catch ()
{ try
{
}
catch ()
{
}
}
finally
try
{
connection open
tx1
tx2
}
catch ()
{
}
conection close
case 1: connection open : both trasaction are success : normal : connection is

closed
case 2: connection open : first transaction is fail : catch block is matched :
normal termination : connection is closed
case 3: connection open : second transaction is fail: catch block is not
mateched :abnormal termination : connection is not closed
To close the connection both normal & abnormal cases use finally block because the
finally block code executed both normal & abnormal cases.
Case 1:NT
try
{ System.out.println("try");
}
{ System.out.println("catch");
}
finally
{ System.out.println("finally");
}
case 2: NT
try
}
}
finally
}
case 3:ABT
try
}
catch (NullPointerException ae)
}
finally
}
case 4: ABT
try
}
}
finally
}
case 5: ABT
try
}
catch(ArithmeticException ae)
}
finally
}
case 6:
try
}
finally
}
In two cases finally block won’t be executed

Case 1: whenever the control is entered into try block then only finally
block will be executed otherwise it is not executed
class Test
try
}
finally
{ System.out.println("finally block");
}
System.out.println("rest of the code");
}
}
case 2:
class Test
{
try
System.exit(0);
}
finally
{ System.out.println("finally block");
}
System.out.println("rest of the code");
}
}
interview :
case 1:
class Test
{
try
}
catch(Exception e)
{ System.out.println("ratan".charAt(20));
}
finally
{ int[] a={10,20,30};
System.out.println(a[9]);
}
}
}
case 2:
class Test
{ int m1()
{ try
{ return 10;
}
catch(Exception e)
{ return 20;
}
finally
{ return 30;
}
}
{ int a = new Test().m1();
System.out.println("return value="+a);
}
}
class Test
{
void disp(){}
{
Test t = new Test();
t.disp();
t=null;
t.disp(); java.lang.NullPointerException
String str= null;
System.out.println(str.length()); java.lang.NullPointerException
}
}
throws keyword
case 1:
class Test
{ void studentDetails() throws InterruptedException
{ System.out.println("suneel babu is sleeping");
Thread.sleep(3000);
System.out.println("do not disturb sir......");
}
void hod()throws InterruptedException
{ studentDetails();
}
void principal()
{ try{hod();}
catch(InterruptedException ie){ie.printStackTrace();}
}
void officeBoy()
{ principal();
}
{ Test t = new Test();
t.officeBoy();
}
}
Note : unchecked exceptions are automatically propagated,

But checked exceptions are propagted using throws keyword.
case 2:
class Test
{ void studentDetails() throws InterruptedException
{ System.out.println("suneel babu is sleeping");
Thread.sleep(3000);
System.out.println("do not disturb sir......");
}
void hod()throws InterruptedException
{ studentDetails();
}
void principal()throws InterruptedException
{ hod();
}
void officeBoy()throws InterruptedException
{ principal();
}
public static void main(String[] args)throws InterruptedException
t.officeBoy();
}
}
Note: unchecked exceptions are automatically propagated. But checked exceptions are
propagated using throws keyword.
ex 3:one method can throws multiple exceptions

import java.io.*;
class Test
{ void m2()throws FileNotFoundException,InterruptedException
{ FileInputStream fis = new FileInputStream("abc.txt");
Thread.sleep(2000);
System.out.println("Exceptions are handled");
}
void m1()
{ try{m2();}
catch(FileNotFoundException | InterruptedException f)
{f.printStackTrace();}
}
t.m1();
}
}
ex-4: use the root cls to throws all exceptions.

import java.io.*;
class Test
{ void m2()throws Exception
Thread.sleep(2000);
}
void m1()
{ try{m2();}
catch(Exception f)
}
t.m1();
}
}
ex5:
import java.io.*;
class Test
{ void m2()throws FileNotFoundException,InterruptedException
Thread.sleep(2000);
}
void m1() throws InterruptedException
{ try{m2();}
catch(FileNotFoundException f)
}
try{t.m1();}
catch(InterruptedException ie){ie.printStackTrace();}
}
}
throw
ex: here we are throwing predefiend exception which is not recommanded.
Because the predefined exceptions are having fixed meaning.
import java.util.*;
class Test
{ static void validate(int age)
{ if (age>18)
{ System.out.println("eligible for mrg");
}
else
{ throw new ArithmeticException("not eligible for marriage");
}
}
{ Scanner s=new Scanner(System.in);
System.out.println("please enter your age ");
int age = s.nextInt();
Test.validate(age);
}
}
userdefiend exception
1. userdefined checked exception.

a. default cons : Exception without description
b. params cons : Exception with description.
class InvalidAgeException extends Exception

{
}
2. userdefined un-checked exception

a. default cons : Exception without description
b. params cons : Exception with description.
class InvalidAgeException extends RuntimeException

{
}
ex: userdefined unchecked exception : with default constructor : without

discription.
step 1: create the exception
{ //deault cons
}
step 2: use that exception in our project.

import java.util.*;
class Test
{ if (age>18)
}
else
{ throw new InvalidAgeException();
}
}
Test.validate(age);
}
}
ex: userdefined unchecked exception : with params constructor : with discription.

{ InvalidAgeException(String str)
{ super(str);
}
}
step 2 : use the exception in our project

import java.util.*;
class Test
{ if (age>18)
}
else
{ throw new InvalidAgeException("u r not eliible to mrg");
}
}
Test.validate(age);
}
}
ex: userdefined checked exception : with params constructor : with discription.

class InvalidAgeException extends Exception
{ InvalidAgeException(String str)
{ super(str);
}
}
step 2 : use the exception in our project

import java.util.*;
class Test
{ static void validate(int age) throws InvalidAgeException
{ if (age>18)
}
else
{ throw new InvalidAgeException("u r not eliible to mrg");
}
}
public static void main(String[] args) throws InvalidAgeException
Test.validate(age);
}
}
try
catch
finally
throws
throw
Assignment : java.lang.NoClassDefFoundError vs java.lang.ClassNotFoundException
Assignment : when we will get StackOverflowError.

class Test
{ void m2()
{ System.out.println("m2 method");
m1();
}
void m1()
{ m2();
System.out.println("m1 method");
}
t.m1();
}
}
when we call the method that method name stored in stack memroy
once the method is completed it is destoryed from stack.
............StackOverflowError
m2
m1
m2
m1
m2
m1
main
Assignment : can we create the userdefined errors.

yes : write the example
no : no example
ArithmeticException
StringIndexOutOfBoundsException
System.out.println("ratan".cahrAt(12));
ArrayIndexOutOfBoundsException
int[] a = {10,20,30}
System.out.println(a[8]);
java.lang.NegativeArraySizeException
int[] a = new int[-5];
InterruptedException
Thread.sleep(1000)
FileNotFoundException
FileInputStream fis = new FileInputStream("abc.txt");
NullPointerException:
String str = null;
System.out.println(str.length());
Test t = new Test();

t.wish();
t=null;
t.wish();
NumberFormatException:
Integer i = new Integer("10"); // valid
Integer i = new Integer("ten"); // NFE

Exception handling

Uploaded by

Exception handling

Uploaded by

Exception handling

In application whenever the exception occurred,

There are two ways to handle the excpetion,

once we handle the exception

//int[] arr = new int[-6];

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

FileInputStream fis = new FileInputStream("abc.txt");

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

Note: Whether it is a checked Exception or unchecked exception exceptions are

It is possible to handle the exceptions by using try-catch blocks or throws keyword

Error is an un-checked type exception.

Exception handling keywords:

There are two ways to handle the exceptions in java.

Exception handling by using try–catch blocks:

Application without try-catch blocks

Application with try-catch blocks:

ex 3: If there is no exception in try block the corresponding catch blocks are

ex - 4: In Exception handling independent try block declaration is not allowed.

ex- 5: In between try-catch blocks it is not possible to declare any statements.

Category-1 : try with multiple catch blocks

case 4: Parent to child :

Category-2 pipe symbol java 7v

case 3: mixing of both checked & uncheked

case 4: Invalid : not possible to take both parent & child

Category-3 try-with resources java 7

FileNotFoundException is a child class of IOException, so taking catch block of the

Category-4 printing Exception information

case 2: if we are not handled exception so The JVM Internally uses

case 3: Exception Propagation.

Category-5 nested try-catch

case 1: connection open : both trasaction are success : normal : connection is

In two cases finally block won’t be executed

Note : unchecked exceptions are automatically propagated,

ex 3:one method can throws multiple exceptions

ex-4: use the root cls to throws all exceptions.

1. userdefined checked exception.

class InvalidAgeException extends Exception

2. userdefined un-checked exception

class InvalidAgeException extends RuntimeException

ex: userdefined unchecked exception : with default constructor : without

step 2: use that exception in our project.

ex: userdefined unchecked exception : with params constructor : with discription.

step 2 : use the exception in our project

ex: userdefined checked exception : with params constructor : with discription.

step 2 : use the exception in our project

Assignment : java.lang.NoClassDefFoundError vs java.lang.ClassNotFoundException

Assignment : when we will get StackOverflowError.

Assignment : can we create the userdefined errors.

Test t = new Test();

You might also like