Exceptions in java contains info about checked unchecked exceptions also methods for handling them. it also contains info about keywords like throw throws catch finally etc.

1. Submitted to:
Mr. Vijay Yadav
(Asst. Prof.)
Submitted by:
Umang Poddar

2.  An exception is an abnormal condition that arises in a
code sequence at run time.
 It is a run-time error that terminates the execution of a
program.
 Exception gives us another opportunity to recover from
the abnormality by taking corrective actions.
 Some common exceptions are :-
• arithmeticexceptions( e.g. division by zero)
• arrayindexoutofboundsexception (e.g. index out of
bounds)
• filenotfoundexception (e.g. file to be open not found)

3.  Exception handling is the process of taking corrective actions by which
flow of program can be maintained.
 A java exception is an object that describes an exceptional
condition that has occurred in a code.
 The exception is caught and processed.
 Java exceptional handling is managed via five keywords: try,
catch, throw, throws and finally.
E.g.- class Exc0{
Public static void main(string args[]) {
Int d=0;
Int a=42/d;
}}
java.lang.arithmeticexception: / by zero
At Exc0.main(Exc0’java:4)

4. Object
Throwable
Exception
IO Exception
File not Found
SQL Exception
Run Time Exception
Error
Arithmetic Exception
ArrayIndexOutofBound Exception
NullPointer Exception
VirtualMachine Exception

5.  Checked Exceptions
 Checked exceptions are those exceptions that are checked at
compile time. If some code within a method throws a checked
exception, then the method must either handle the exception or it
must specify the exception using throws keyword.
 Checked Exceptions are:-
• All user defined exceptions
• SQL exceptions

6.  Unchecked Exceptions
 Exceptions which are not checked for during compile time are
called unchecked exception. It means if your program is throwing
an unchecked exception and even if you didn’t handle/declare
that exception, the program won’t give a compilation error.
 Some Unchecked Exceptions are:-
• NullPointer Exception
• Arrayindexoutofbiunds Exceptions

7. The try block contains a block of program statements within which an
exception might occur. To guard against and handle a run-time error,
simply enclose the code that you want to monitor inside a try block. A try
block is always followed by a catch block, which handles the exception that
occurs in associated try block. A try block must followed by a Catch block
or Finally block or both.
Syntax: try
{
//statements that may cause an exception
}
catch (exception(type) e(object))
{
//error handling code
}

8. Class Exc2{
public static void main(string args[])
{ int d, a;
try{//monitor a block of code
d = 0;
a = 42/d;
system.out.println(“this will not be prined”);
} catch (ArithmeticException e){ //catch divided-by-zero error
system.out.println(“Division by zero”);
}
system.out.println(“after catch statement.”);
}
}
OUTPUT:-
Division by zero
After catch statement

9. In some cases, more than one exception could be raised by a single piece of code.
To handle this type of situation, we can specify two or more catch clauses, each
catching a different type of exception. When an exception is thrown, each catch
statement is inspected in order, and the first one whose type matches that of the
exception is executed. After one catch statement executes, the others are
skipped, and execution continues after the try/catch block.

10. public class TestMultipleCatchBlock{
public static void main(String args[]){
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e){System.out.println("task1 is completed");}
catch(ArrayIndexOutOfBoundsException e)
{System.out.println("task 2 completed");}
catch(Exception e){System.out.println("common task completed");}
System.out.println("rest of the code..."); }
}
Output: task1 completed
rest of the code...

11. The try block within a try block is known as nested try block. Sometimes a
situation may arise where a part of a block may cause one error and the entire
block itself may cause another error. In such cases, exception handlers have to
be nested. If no catch block matches, then the java run-time system will handle the
exception.

12. public class Nested {
public static void main(String[] args) {
try {
System.out.println("Outer try block starts");
try {
System.out.println("Inner try block starts");
int res = 5 / 0;
} catch (InputMismatchException e) {
System.out.println("InputMismatchException caught");
} finally {
System.out.println("Inner final");
}
} catch (ArithmeticException e) {
System.out.println("ArithmeticException caught");
} finally {
System.out.println("Outer finally");
}
}
}
Output:
Outer try block starts
Inner try block starts
Inner final
ArithmeticException caught
Outer finally Outer finally