Java exception-handling

1
Java Exception Handling
Copyrights, All rights reserved.
All details provided in this slide is only for personal
learning, and cannot be distributed publicly, without
written permission of the Author.
Contact milogik652@gmail.com to Learn Core Java
and any other Java related Technologies

Contents
1. What is an Exception?
2. Purpose of Exceptions
3. Exception Keywords
4. Exception Control Flow
5. Inbuilt Exceptions
6. Exceptions in other Packages/Frameworks
7. Order of Catching Exceptions
8. Nested Exceptions
9. Exception class Hierarchy
10.Checked & Unchecked Exceptions
11.User Defined Checked Exceptions
12.User Defined Unchecked Exceptions
Contact milogik652@gmail.com to Learn Core Java,
Spring, Spring Boot, Hibernate, Microservices or any
other Java related Technologies

1. What is an Exception?
An Exception is run time problem or error which
occurs, when program is under execution.
An Exception may occur due to Environment, bad
programming, or due to unexpected input data.
For example:
When you access an array element which is beyond
the range of array, an
java.lang.ArrayIndexOutOfBoundsException is
thrown.
In C Language there is no built in Exception handling,
developer need to manually write the code to check
the range, using multiple if statements, which clutters
the code.Contact milogik652@gmail.com to Learn Core Java, Spring, Spring Boot,
Hibernate, Microservices or any other Java related Technologies

What is an Exception?
Car Wheel
broken on run,
An exception
handler avoids
crashing/overtu
rn/accident of
car, and slows
down in next
few meters
Contact milogik652@gmail.com to Learn Core Java, Spring, Spring Boot,

2. Purpose of Exceptions?
1. Exceptions improves User Experience
2. makes the Program more Robust, avoiding Crashes
3. Helps developer by generating basic Exception
Handling code
4. Improves code readability separating Business Logic
and Exception handling code
5. Stack Unwinding
Java has built in support for Exception handling.

3. Exception Keywords
Java provides inbuilt Exception Handling as
• 5 keywords
• Few inbuilt classes(Exception related classes)
Below are keywords used in Exception handling
1.try - set of program statements which may throw an
Exception need to be enclosed within try block
2.catch – set of program statements which can handle
Exception scenario need to be enclosed in catch
block. A try block can have multiple catch blocks.
3.throw – throw keyword is used to manually throw an
Exception. Is used in the method body.

7
Exception Keywords
Code snippet with try, catch, throw keywords
try
{
//statements
throw new Exception(); //optional
}
catch(Exception e)
{
System.out.println(“Exception occurred”+ e);
}

8
4.throws – is used along with method declaration to
specify that a method can throw one or more
Exceptions. Is used with method declaration.
void met() throws AbcException, XyzException;
Exception can be thrown across methods in different
classes, which can be different packages.
5.finally – statements in finally block gets executed
whether are not Exception occurs. Generally releasing
used resources, like closing file, network
connections,etc… need to be done in finally block. finally
block gets executed, before returning from the method ,
in all cases.

9
try
{
//statements
}
catch(Exception1 e1)
{
//statements
}
finally
{
//statements
}

10
4. Control Flow of Exceptions:
Flow of Execution when Exception Occurs
void met1()
{
//business logic
try{
//business logic
//exception occurred
//when above exception is thrown, these statements does not execute
}
catch(Exception et)
{
//statements in catch block gets executed only if exception occurs
}
}

11
Execution Flow when Exception does not occur
void met1()
{
//business logic
try{
//business logic
//full code in try block gets executed if exception is not thrown
}
catch(Exception et)
{
//if exception is not thrown, statements in catch block does not execute
}
finally
{
//statements here always gets executed whether or not Exception occurs
}
} Contact milogik652@gmail.com to Learn Core Java, Spring, Spring Boot,

12
try with finally and without catch
As already known finally block can exist only with a try
block, and may be without catch block. since the
Exception is either directly or indirectly thrown from the
statements within try block, and since this Exception is
not being handled within the method, as there is no
catch block.
throws statement may need to be used in method
declaration, however we want some statements to be
always executed(either Exception occurs or not)
before returning this method, such statements need to
be placed in finally block

13
void met() throws XyzException
{
//statements here
try{
//statements here
}
finally
{
//statements which need ot be always executed
}
}

5. List of some built in Exceptions
Below Exceptions are in java.lang package
There a number of other Exceptions like IOException,
SocketException, etc…
Exception class name Occurs when
NullPointerException referring a Reference which is null
ArrayIndexOutofBoundsException accessing an array element which doesn’t exist(i..e
actual size of array is < index being referred)
NumberFormatException occurs when Integer.parseInt(“10”), and given string
cannot be converted into valid Integer
ArithmeticException dividing by zero
OutofMemoryError Heap memory is full(UnChecked)
StringIndexOutOfBoundsException referring a String index which doesn’t exist
StackOverflowError Stack memory is full, generally occurs due to
nested calls(UnChecked)
14

15
6. Exceptions in other Packages & Frameworks:
Most of commonly used Exceptions exist in default
package(i..e java.lang)
There are a number of Exceptions such as
SQLException(defined in java.sql package),
ConnectException, UnknownHostException(defined in
java.net package)
Similarly there can be a number of Pre defined/Custom
Exceptions which are defined by its own packages or
Framework, for it’s specific purpose, you need to refer
documentation of that specific Framework to know the
purpose of it.

16
7. Order of catching Exceptions
A try block can have zero or more catch blocks.
When a try block has multiple catch blocks, the derived
most Exceptions classes need to be caught first, and
then Base Exception classes need to be caught, else it
leads to Compiler error due to unreachable code.

17
Order of catching Exceptions
This applies to Custom Exception classes as well.
try{
//program statements
}
catch(ArrayIndexOutofBoundsException abe)
{
//
}
catch(Exception e)
{
//

18
8. Nested Exceptions
It is possible to have a try block within another try block.
A catch block can have another try catch blocks
try
{
//stmt 1
try{
//stmt 2
}catch(Exception et){ et.printStackTrace(); }
//stmt 3
}catch(Exception e)
{
e.printStackTrace();

19
Though the flow of program execution can be controlled
using Exceptions.
Exceptions need to be used only to handle Exception
Scenarios, and should not be used to actually control
flow of execution of program.
java.lang.Exception is base class of all Exception
classes.
Exception class has below methods.
1.printStackTrace()

Object
Throwable
Error Exception
RuntimeException
20

21
Difference between Exception and Error classes
The first one catches all subclasses of Throwable (this
includes Exception and Error), the second one catches
all subclasses of Exception.
Error is programmatically unrecoverable in any way and
is usually not to be caught, except for logging purposes
(which passes it through again).
Exception is programmatically recoverable.
Its subclass RuntimeException indicates a programming
error and is not mandatory to be caught.

22
try{
}
catch(Throwable t){}
try{
}catch(Exception e){}

⮚ In Java, exceptions are objects. When you throw an
exception, you throw an object.
⮚ You can't throw just any object as an exception. you can
throw only those objects whose classes descend
from Throwable.
⮚ Throwable serves as the base class for an entire family
of classes, declared in java.lang, that your program can
instantiate and throw.
⮚ Throwable has two direct subclasses, Exception and
Error. 23

⮚ java.lang.Exception class represents the exceptions
which are mainly caused by the application itself.
⮚ For example, NullPointerException occurs when an
application tries to access null object or
ClassCastException occurs when an application tries to
cast incompatible class types.
⮚ Errors (members of the Error family) are usually thrown for
more serious problems, such as OutOfMemoryError or
StackOverflowError, that may not be so easy to handle.
⮚ In general, code you write should throw only exceptions, not
errors.
⮚ Errors are usually thrown by the methods of the Java API, or
by the Java virtual machine itself, due to environment issues.
24
Exception class Hierarchy

25
Exception class is base class of all Exception classes
eg. ArithmeticException,
NullPointerException,
ArrayIndexOutofBoundsException,etc…

26
11. Checked & Unchecked Exceptions
Exceptions are broadly classified into two
1.Checked Exceptions – These are the Exceptions
which are checked by Compiler, and need to be
handled(using try, catch) or thrown(using throws)
explicitly.
All Checked Exceptions are derived from Exception
class
2.UnChecked Exceptions – It is not mandatory to
handle or throw(using throws) Unchecked Exceptions
explicitly.
All Unchecked Exceptions are derived from
RuntimeException class

27
Since forcing a developer to catch each and every
Exception is not a good option, Java provides
UnChecked exceptions. These are the exceptions
which need not be explicitly handled by the developer.

12. How to create User defined Checked Exception
29

13. How to create user defined UnChecked Exception
30

Thank You!
31

Java exception-handling

Recommended

More Related Content

What's hot (20)

Similar to Java exception-handling (20)

Recently uploaded (20)

Java exception-handling