Exception Handling in Java with Examples.pptx

EXCEPTION
HANDLING
By:
Archna Aggarwal

ERRORS AND EXCEPTIONS
Error
Errors are the wrongs that can make a program
to go wrong. An error may produce an incorrect
output or may terminate the execution of the
program abruptly or even may cause the system
to crash.
Types of error
Compile Time Error
Run Time Error

COMPILE TIME ERROR
 All syntax errors are detected and displayed by
the Java compiler, therefore these errors are
known as compile time errors; which generates a
message indicating the type of error and the
position in the Java source file where the error
occurred.
 The most common compile time errors are:
 Missing semicolon
 Missing brackets in classes and methods
 Misspelling of identifiers and keywords
 Missing double quotes
 Use of undeclared variables
 And so on…

RUNTIME ERROR
 An error that occurs during the execution of a program
are called Run Time Error. That is , a program may
compile successfully creating the .class file but may not
run properly. Such programs may produce wrong result
due to wrong logic or may terminate due to error such as
stack overflow. Runtime errors indicate bugs in the
program.
 The most common runtime errors are:
 Dividing an integer by zero
 Accessing an element that is out of the bounds of an array
 Trying to store a value into an array of an incompatible class
or type
 Accessing a character that is out of bounds of a string
 And do on…

EXCEPTION
 An exception is a condition that is caused by a
run-time error in the program.
 A Java Exception is an object that describes the
exception that occurs in a program.
 When an exceptional events occurs in java, an
exception is said to be thrown. The code that is
responsible for doing something about the
exception is called an exception handler.

TYPES OF EXCEPTION
 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. Unchecked exception are ignored at
compile time.

class UncaughtException
{
public static void main(String args[])
{
int a = 0;
int b = 7/a; // Divide by zero, will lead to exception
}
}

EXCEPTION HANDLING MECHANISM
Exception Handling Mechanism includes following tasks
1. Find the problem (Hit the exception)
2. Inform that an error has occurred (Throw the exception)
3. Receive the error information (Catch the exception)
4. Take corrective actions (Handle the exception)
In java, exception handling is done using five keywords,
 try
 catch
 throw
 throws
 Finally
 Exception handling is done by transferring the execution of a
program to an appropriate exception handler when exception occurs.

TRY BLOCK
 Java try block is used to enclose the code that might throw
an exception. It must be used within the method.
 Java try block must be followed by either catch or finally
block.
 Syntax of java try-catch
try{
//code that may throw exception
}catch(Exception_class_Name ref){}
 Syntax of try-finally block
try{
//code that may throw exception
}finally{}

CATCH BLOCK
 Java catch block is used to handle the Exception.
It must be used after the try block only.
 You can use multiple catch block with a single
try.

PROBLEM WITHOUT EXCEPTION
HANDLING
public class Test
{
{
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
public class Test
{
{
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
rest of the code...

WORKING OF JAVA TRY-CATCH BLOCK

MULTIPLE CATCH BLOCKS
 A try block can be followed by multiple catch
blocks. You can have any number of catch blocks
after a single try block.
 If an exception occurs in the try block, the
exception is passed to the first catch block in the
list.
 If the exception type of exception, matches with
the first catch block it gets caught, if not the
exception is passed down to the next catch block.
This continue until the exception is caught or
falls through all catches.

EXAMPLE FOR MULTIPLE CATCH BLOCKS
class Excep
{
public static void main(String[] args)
{
try
{
int arr[]={1,2};
arr[2]=3/0;
}
catch(ArithmeticException ae)
{
System.out.println("divide by zero");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("array index out of bound
exception");
}
}
}
Output :
divide by zero

NESTED TRY STATEMENT
 try statement can be nested inside another
block of try.
 Nested try block is used when a part of a block
may cause one error while entire block may cause
another error.
 In case if inner try block does not have a catch
handler for a particular exception then the
outer try is checked for match.

Syntax:
....
try
{
statement 1;
statement 2;
try
{
statement 1;
statement 2;
}
catch(Exception e)
{
}
}
catch(Exception e)
{
}
....

EXAMPLE OF NESTED TRY STATEMENT
class Excep
{
{
try
{
int arr[]={5,0,1,2};
try
{
int x=arr[3]/arr[1];
}
catch(ArithmeticException ae)
{
System.out.println("divide by zero");
}
arr[4]=3;
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("array index out of bound exception");
}
}
}

FINALLY CLAUSE
 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.

EXAMPLE DEMONSTRATING FINALLY CLAUSE
Class ExceptionTest
{
{
int a[]= new int[2];
System.out.println("out of try");
try
{
System.out.println("Access invalid element"+
a[3]);
/* the above statement will throw
ArrayIndexOutOfBoundException */
}
finally
{
System.out.println("finally is always executed.");
}
}
}
Output :
Out of try
finally is always executed.
Exception in thread main java.
Lang. exception array Index
out of bound exception.

THROW KEYWORD
 throw keyword is used to throw an exception explicitly.
Only object of Throwable class or its sub classes can be
thrown. Program execution stops on
encountering throw statement, and the closest catch
statement is checked for matching type of exception.
 Syntax :
throw ThrowableInstance
 Creating Instance of Throwable class
 two possible ways to get an instance of class Throwable,
 Using a parameter in catch block.
 Creating instance with new operator.
e.g. new NullPointerException("test");
This constructs an instance of NullPointerException with
name test.

EXAMPLE OF THROW KEYWORD
class Test
{
static void avg()
{
try
{
throw new ArithmeticException("demo");
}
{
System.out.println("Exception caught");
}
}
{
avg();
}
}

THROWS KEYWORD
 Any method capable of causing exceptions must list
all the exceptions possible during its execution, so
that anyone calling that method gets a prior
knowledge about which exceptions to handle. A
method can do so by using the throws keyword.
 Syntax :
type method_name(parameter_list) throws
exception_list
{
//definition of method
}

EXAMPLE DEMONSTRATING THROWS KEYWORD
class Test
{
static void check() throws ArithmeticException
{
System.out.println("Inside check function");
throw new ArithmeticException("demo");
}
{
try
{
check();
}
{
System.out.println("caught" + e);
}
}
}

DIFFERENCE BETWEEN THROW AND THROWS
IN JAVA
No
.
throw throws
1) Java throw keyword is used to
explicitly throw an exception.
Java throws keyword is used
to declare an exception.
2) Throw is followed by an
instance.
Throws is followed by class.
3) Throw is used within the
method.
Throws is used with the
method signature.
4) You cannot throw multiple
exceptions.
You can declare multiple
exceptions e.g.
public void method()throws
IOException,SQLException.

import java.lang.Exception;
import java.io.*;
import java.util.*;
class MyException extends Exception
{
MyException(String msg)
{
super(msg);
}
}
Creating our own
Exception

class exp82
{
public static void main(String args[])throws IOException
{
try
{
Scanner br=new Scanner(System.in);
System.out.println("Enter Number:");
int n=br.nextInt();
if(n%2==0)
{
System.out.println("Number is Even");
}
else
{
throw new MyException("Number is Not Even
Number");
}
}

catch(MyException e)
{
System.out.println("Caught my
exception");
System.out.println(e.getMessage());
}
finally
{
System.out.println("End");
}
}
}

Exception Handling in Java with Examples.pptx

More Related Content

Similar to Exception Handling in Java with Examples.pptx

Recently uploaded

Exception Handling in Java with Examples.pptx