The document provides an overview of exception handling in programming, detailing the definition of exceptions, their types (checked and unchecked), and the keywords used for handling exceptions like try, catch, throw, and finally. It includes code examples to illustrate the occurrence of exceptions and the structure of try-catch blocks. Additionally, it explains the proper use of throw and throws keywords in method signatures for declaring exceptions.

1. {
PRESENTATION ON
Exception
Handling

2. What is an exception?
*An exception is an error condition that
changes the normal flow of control in a
program
*When an Exception occurs the normal flow
of the program is disrupted and the
program/Application terminates
abnormally, which is not recommended,
therefore these exceptions are to be handled

3. Why Exception Occurs?
An exception can occur for many different
reasons, below given are some scenarios where
exception occurs.
>>A user has entered invalid data.
>>A file that needs to be opened cannot be
found.
>>A network connection has been lost in the
middle of communications or the JVM has run
out of memory.

5. Exception Hierarchy

6. Exception Has two Main
classes :
1. Checked exceptions : known as
compile time exceptions.
Programmer should take care of
(handle) these exceptions
2. Unchecked exceptions : Known as
Runtime Exceptions.
These include programming bugs, such
as logic error also.

7. Keyword Description
try The "try" keyword is used to specify a block
where we should place an exception code. It
means we can't use try block alone. 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
necessary code of the program. It is executed
whether 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 specifies that there may occur an
exception in the method. It doesn't throw an
exception. It is always used with method
signature.

8. Checked exceptions

9. 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);
}
} 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);
Example

10. Unchecked exceptions

11. Example
public class Unchecked_Demo {
public static void main(String args[])
{
int num[]={1,2,3,4};
System.out.println(num[5]);
}
} Output:
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 5 at
Exceptions.Unchecked_Demo.main(Unchecked_D
emo.java:8

12. Exception Handling Terms
1.Try – used to enclose a segment of code that may
produce a exception
2.Catch – placed directly after the try block to handle one
or more exception types
3.Throw – to generate an exception or to describe an
instance of an exception
4.Finally – optional statement used after a try-catch block
to run a segment of code regardless if a exception is
generated

13. Try – Catch Block
Try – used to enclose a segment of code that
may produce a exception
Catch – placed directly after the try block to
handle one or more exception types
try {
statements;
}
catch(Exception ex) {
perform operations before exits;
throw ex;
}

14. Multiple catch statements
try {
<code segment that may
throw an exception..>
} catch (IOException e) {
System.out.println(e.getMessage());
} catch (FileNotFoundException e){
System.out.println(“FileNotFound!”);
}

15. Nested try-catch block
try {
statement 1;
try {
statement 2;
statement 3;
}
catch(Exception e) { }
}
catch(Exception e) { }

16. By using Throw
THROW-generate an exception or to describe an instance
of an exception
Define a class:
public class EmptyStackException extends Exception {
}
Here is how you use the class:
public class Stack {
public Object Pop() throws EmptyStackException
{
if (Empty()) throw new EmptyStackException();
...
}
}
Note that you must use new to create an exception
object; you cannot just throw an exception.

17. Example
static class Exception2{
static int sum(int num1, int num2){
if (num1 == 0)
throw new ArithmeticException("First parameter is not
valid");
else
System.out.println("Both parameters are correct!!");
return num1+num2; }
public static void main(String args[]){
int res=sum(1,12);
System.out.println(res);
System.out.println("Continue Next statements");
}
}

18. The finally
try {
statements;
}
catch(TheExceptionex) {
handling ex;
}
finally {
finalStatements;
}

19. Example
public static void main(String[] arg){
try{
int i = 10/0;
} catch(Exception ex){
System.out.println("Inside 1st catch Block");
} finally {
System.out.println("Inside 1st finally block");
}
try{
int i = 10/10;
} catch(Exception ex){
System.out.println("Inside 2nd catch Block");
} finally {
System.out.println("Inside 2nd finally block");
}
} Inside 1st catch Block
Inside 1st finally block
Inside 2nd finally block

20. Thanks All