Chapter 5

CHAPTER 5 EXCEPTION HANDLING
By
Sirage Zeynu (M.Tech)
School of Computing

13-04-2021 Exception handling 2
Outlines
1.Exception handling overview
2.The causes of exceptions
3.The Throwable class hierarchy
4.Handling of an exception
5.The throw statements
6.The finally clause

 An exception is an indication of a problem that occurs during a
program’s execution.
 An exception is a runtime error.
 The name “exception” implies that the problem occurs
infrequently - if the “rule” is that a statement normally executes
correctly, and then the “exception to the rule” is that a problem
occurs.
 When an exception occurs, the normal execution flow of the
program will be interrupted.
 Exception handling enables you to create applications that can
resolve (or handle) exceptions.
Exception Handling Overview(1)

 In many cases, handling an exception allows a program to
continue executing as if no problem had been encountered.
 A more severe problem could prevent a program from
continuing normal execution, instead requiring it to notify the
user of the problem before terminating in a controlled manner.
 Exceptions occur for various reasons.

 The user may enter an invalid input, for example, or the
program may attempt to open a file that doesn't exist, or the
network connection may hang up, or the program may
attempt to access an out-of-bounds array element.
 Exception handling – resolving exceptions that may occur so
program can continue or terminate gracefully
 Exception handling enables programmers to create programs
that are more robust and fault-tolerant

Here is an example. The program shown below terminates
abnormally if you enter a floating-point value instead of an
integer.

 If 12.5 is entered for the integer variable, the program will terminate
unexpectedly by generating the exception shown below.
Note that several lines of information are displayed above in response to the
invalid input.
This information, known as the stack trace, includes the name of the
exception (java.util.InputMismatchException) followed by the method call
stack at the time the exception occurred.

 The stack trace helps in debugging a program.
 Starting from the last line of the stack trace, you see that the
exception was detected in line 9 of the main method.
 Each line of the stack trace contains the class name and method
(ExceptionDemo.main) along with the file name and line number
(ExceptionDemo.java: 9).
 Moving up the stack trace, you see that the exception occurred in
line 1485 in the nextInt method of the Scanner class, the exception
occurred in line 2117 in the overloaded nextInt method of the
Scanner class, the exception occurred in line 2076 in the next
method of the Scanner class, the exception occurred in line 864 in
the throwFor method of the Scanner class.

But the following program reports an error message if 12.5 is entered for the
integer variable and the program continues normally executing after displaying
the error message.

 A Java exception is an instance of a class derived from
Throwable.
 The Throwable class is contained in the java.lang package, and
subclasses of Throwable are contained in various packages.
 Errors related to GUI components are included in the java.awt
package; numeric exceptions are included in the java.lang
package because they are related to the java.lang.Number
class.
 You can create your own exception classes by extending
Throwable or a subclass of Throwable. Figure below shows
some of Java's predefined exception classes.
Exceptions and Exception Types

System errors are thrown by
JVM and represented in the
Error class. The Error class
describes internal system
errors. Such errors rarely
occur. If one does, there is
little you can do beyond
notifying the user and trying
to terminate the program
gracefully.
System Errors

Exception describes errors
caused by your program
and external circumstances.
These errors can be caught
and handled by your
program.
Exceptions

Runtime Exceptions

 Errors are thrown by the JVM and represented in the Error class.
 Errors are not caused due to user program.
 The Error class describes internal system errors. Such errors rarely
occur.
 If one does, there is little you can do beyond notifying the user and
trying to terminate the program gracefully.
 Errors that result from program activity are represented by
subcasses of Exception.
 Exceptions are represented in the Exception class, which describes
errors caused by your program and by external circumstances.
 These errors can be caught and handled by your program.

ClassNotFoundE
xception
Attempt to use a class that does not exist. This exception would occur, for
example, if you tried to run a nonexistent class using the java command, or if
your program was composed of, say, three class files, only two of which
could be found.
IOException Related to input/output operations, such as invalid input, reading
past the end of a file, and opening a nonexistent file. Examples of
subclasses of IOException are InterruptedIOException,
EOFException (EOF is short for End Of File), and FileNotFound
Exception.
AWTException Exceptions in GUI components
Examples of subclasses of Exception

 Runtime exceptions are represented in the RuntimeException
class, which describes programming errors, such as bad
casting, accessing an out-of-bounds array, and numeric errors.
Runtime exceptions are generally thrown by the JVM.
 Examples of subclasses are shown below.
Runtime exceptions

ArithmeticException Dividing an integer by zero. Note that
floating-point arithmetic does not throw
exceptions.
NullPointerException Attempt to access an object through a null
reference variable.
IndexOutOfBoundsException Index to an array is out of range.
IllegalArgumentException A method is passed an argument that is
illegal or inappropriate.

 RuntimeException, Error, and their subclasses are known as
unchecked exceptions.
 All other exceptions are known as checked exceptions, meaning
that the compiler forces the programmer to check and deal with
them.
 In most cases, unchecked exceptions reflect programming logic
errors that are not recoverable.
 For example, a NullPointerException is thrown if you access an
object through a reference variable before an object is assigned to
it; an IndexOutOfBoundsException is thrown if you access an
element in an array outside the bounds of the array.
 These are logic errors that should be corrected in the program.

difference between checked and unchecked exception
 The main difference between checked and unchecked
exception is that the checked exceptions are checked at
compile-time while unchecked exceptions are checked at run-
time.
What are checked exceptions?
 Checked exceptions are checked at compile-time. It means if a
method is throwing a checked exception then it should handle
the exception using try-catch block or it should declare the
exception using throws keyword, otherwise the program will
give a compilation error.

What are Unchecked exceptions?
 Unchecked exceptions are not checked at compile time. 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.
 Most of the times these exception occurs due to the bad data
provided by user during the user-program interaction.
 It is up to the programmer to judge the conditions in advance,
that can cause such exceptions and handle them appropriately.
All Unchecked exceptions are direct sub classes
of RuntimeException class.

 Java exception handling is managed via 5 keywords:
try, catch, throw, throws and finally.
 Program statements that you want to monitor for exceptions are
contained within a try block.
 If an exception occurs within a try block, it is thrown. Your code
can catch this exception using catch and handle it.
 System-generated exceptions are automatically thrown by java
run-time system.
 To manually throw an exception, use the keyword throw.

 The try block contains set of statements where an exception
can occur.
 A try block is always followed by a catch block, which
handles the exception that occurs in associated try block. A
try block must be followed by catch blocks or finally block or
both.
Syntax of try block
try{
//statements that may cause an exception
}
try block

 A catch block is where you handle the exceptions, this block
must follow the try block.
 A single try block can have several catch blocks associated
with it.
 You can catch different exceptions in different catch blocks.
 When an exception occurs in try block, the corresponding
catch block that handles that particular exception executes.
 For example if an arithmetic exception occurs in try block then
the statements enclosed in catch block for arithmetic
exception executes.
Catch block

Using try and catch
General form of try/catch:

Example: try catch block

 Lets see few rules about multiple catch blocks with the help of examples.
 1. single try block can have any number of catch blocks.
2. A generic catch block can handle all the exceptions.
 ArrayIndexOutOfBoundsException or
 ArithmeticException or
 NullPointerException or
 any other type of exception
 3. If no exception occurs in try block then the catch blocks are completely ignored.
4. Corresponding catch blocks execute for that specific type of exception:
catch(ArithmeticException e) is a catch block that can handle ArithmeticException
catch(NullPointerException e) is a catch block that can handle NullPointerException
5. You can also throw exception, which is an advanced topic
Multiple catch blocks in Java

Example of Multiple catch blocks

 A finally block contains all the crucial statements that must be executed
whether exception occurs or not.
 The statements present in this block will always execute regardless of whether
exception occurs in try block or not such as closing a connection, stream etc.
syntax of Finally block
try {
//Statements that may cause an exception
}
catch {
//Handling exception
}
finally {
//Statements to be executed
}
Finally block

A Simple Example of finally block

 exception object is an object of class java.lang.Exception or
some subclass of it.
 When JVM encounters a throw statement, it stops executing
the block in which the throw occurs and will not execute any
additional code in the program unless it encounters a proper
catch statement.
 throw exception object ;
Throw keyword

Throw Example

Throws keyword is used for handling checked exceptions .
By using throws we can declare multiple exceptions in one go.
 What is the need of having throws keyword when you can
handle exception using try-catch?
The throws does the same thing that try-catch does but there are
some cases where you would prefer throws over try-catch.
 For example:
Lets say we have a method myMethod() that has statements that
can throw either ArithmeticException or NullPointerException,
in this case you can use try-catch as shown below:
Throws key word in java

public void myMethod() {
try
{
// Statements that might throw an exception
}
catch (ArithmeticException e) {
// Exception handling statements
}
catch (NullPointerException e) {
} }

public void myMethod() throws ArithmeticException, NullPointerException
{
// Statements that might throw an exception
}
public static void main(String args[]) {
try {
myMethod();
}
catch (ArithmeticException e) {
}
catch (NullPointerException e) {
}}

Throws Example

Example of throws Keyword

1. Throws clause is used to declare an exception, which means it works
similar to the try-catch block. On the other hand throw keyword is used to
throw an exception explicitly.
2. If we see syntax wise than throw is followed by an instance of Exception
class and throws is followed by exception class names.
For example:
throw new ArithmeticException("Arithmetic Exception");
and
throws ArithmeticException;
3. Throw keyword is used in the method body to throw an exception, while
throws is used in method signature to declare the exceptions that can occur in
the statements present in the method.
4. You can throw one exception at a time but you can handle multiple
exceptions by declaring them using throws keyword.
Throw vs Throws in java

For example:
Throw:
void myMethod()
{
//Throwing single exception using throw
throw new ArithmeticException("An integer should not be divided by
zero!!");
}
Throws:
//Declaring multiple exceptions using throws
void myMethod() throws ArithmeticException, NullPointerException
{
//Statements where exception might occur
}

13-04-2021 Introduction to Java and OO Concepts 41

Chapter 5

More Related Content

What's hot

Similar to Chapter 5

More from siragezeynu

Recently uploaded

Chapter 5

Editor's Notes