Exception Handling in

JAVA
Part-2

Instructor Name: Muhammad Fayyaz Awan

Department of Computer Science, COMSATS University Islamabad, Wah Campus, Pakistan
Outline
2

 Recap
 Terms used in Exception Handling
 Common Scenarios where Exceptions may Occur
 User defined Exceptions
 References
Recap
3

• What

An exception is an event that alters the normal flow of the program.

Checked (compile time) and unchecked (runtime) exceptions.
An Error indicates serious problems, unchecked type, mostly occur at runtime
Exception handling is a framework that is used to handle runtime errors.

• Why

To maintain the normal flow of the application/program.

Terms used in Exception Handling
4

• Try-Catch: Piece of code of your program that you want to monitor for
exceptions are contained within a try block. If an exception occurs
within the try block, it is thrown. Catch block can catch this exception
and handle it in some logical manner.

• Finally: Any code that absolutely must be executed before a method

returns, is put in a finally block.

• Throw: System-generated exceptions are automatically thrown by the

Java run-time system. Now if we want to manually throw an exception,
we have to use the throw keyword.
 Terms used in Exception Handling
5

• Throws: If a method is capable of causing an exception that it does not handle, it must
specify this behavior so that callers of the method can guard themselves against that
exception.

You do this by including a throws clause in the method’s declaration. Basically it is used
for IO Exception. A throws clause lists the types of exceptions that a method might
throw.

This is necessary for all exceptions, except those of type Error or Runtime Exception, or
any of their subclasses. All other exceptions that a method can throw must be declared
in the throws clause. If they are not , a compile-time error will result.
Exception Handling (try-catch example slide-1)
6

class ExceptionThrown // The runTime System searches the appropriate Exception handler

{  // in this method also but couldn't have found. So looking forward
 // on the call stack.
 // It throws the Exception(ArithmeticException).     static int computeDivision (int a, int b)
// Appropriate Exception handler is not found within this {
method.         int res =0;
        try
static int divideByZero (int a, int b)         {
{           res = divideByZero (a,b);
                   }
// this statement will cause ArithmeticException(/ by         // doesn't matches with ArithmeticException
zero)         catch (NumberFormatException ex)
        int i = a/b;          {
        return i;            System.out.println ("NumberFormatException is occured"); 
}         }
               return res;
     }
 
Exception handling (try-catch example slide-2)
7

//main method
public static void main(String args[])
{
        int a = 1;
        int b = 0;
          
        try
        {
            int i = computeDivision(a,b); Output:
         }
         // matching ArithmeticException
        catch (ArithmeticException ex) Message String=/ by zero.
        {
// getMessage will print description of exception(here / by zero)
            System.out.println(“Message String=“ +ex.getMessage());
        }
    }

    } This method is used to get the detail message of exception as a

string value.
Multi-Catch Block
8

public class TestMultipleCatchBlock

{ public static void main(String args[])
{
try At a time only one
Exception is occurred and
{ at a time only one catch
int a[]=new int[5]; block is executed.
a[5]=30/0;
} All catch blocks must be
catch (ArithmeticException e) ordered from most specific
{System.out.println("task1 is completed");} to most general i.e. catch
for ArithmeticException
catch (ArrayIndexOutOfBoundsException e) must come before catch for
{System.out.println("task 2 completed");} Exception .
catch (Exception e)
{System.out.println("common task
completed");}
System.out.println("rest of the code...");
}
}
Throw Keyword
9

• throw keyword is used to explicitly throw an exception from a method

or any block of code.

• throw either checked and unchecked exceptions.

• throw keyword is mainly used to throw custom exceptions.

Syntax

throw Instance
Example:
throw new ArithmeticException("/ by zero");
Throw Keyword (Example)
10

// Java program that demonstrates the use of throw //main method 

class ThrowExcep public static void main(String args[])
{     {
    static void fun()         try
    {
        {
        try
        {
            fun();
            throw new NullPointerException("demo");         }
        }         catch(NullPointerException e)
        catch (NullPointerException e)         {
        {             System.out.println("Caught in main.");
            System.out.println("Caught inside fun().");         }
            throw e;     }
// re-throwing the exception
        }
    } } Output:
Caught inside fun().
   Caught in main.
   
Throw Keyword (Example Explanation)
11

• The flow of execution of the program stops immediately after the throw statement is
executed and the nearest enclosing try block is checked to see if it has a catch
statement that matches the type of exception.

• If it finds a match, controlled is transferred to that statement otherwise next

enclosing try block is checked and so on.

• If no matching catch is found then the default exception handler will halt the
program.
Sequence of Events for throw

Preceding step

try block

throw
statement

unmatched catch

matching catch

unmatched catch

next step
Throws Keyword
13

• throws keyword is used in the signature of method to indicate

that this method might throw one of the listed type exceptions.
The caller to these methods has to handle the exception using a
try-catch block.

Syntax

type method_name(parameters) throws exception_list

exception_list is a comma separated list of all the exceptions which a method

might throw.
Throws Keyword
14

Scenario:
In any program, if there is a chance of rising an exception then compiler always warn us
about it and compulsorily we should handle that checked exception, Otherwise we will get
compile time error saying unreported exception XXX must be caught or declared to be
thrown. To prevent this compile time error we can handle the exception in two ways:

1.By using throws keyword

2.By using try catch
Unhandled Exception (Example)
15

//Java program to illustrate error in case 

// of unhandled exception
class tst  Output:
{ error: unreported exception InterruptedException;
must be caught or declared to be thrown
    public static void main(String[] args)
    {
        Thread.sleep(10000);
        System.out.println("Hello");
    } Explanation : In this program, we are getting compile time error
because there is a chance of exception if the main thread is going to
} sleep, other threads get the chance to execute main() method which
will cause InterruptedException.
Use of throws Keyword (Example)
16

// Java program to illustrate throws

class tst 
{
public static void main(String[] args) throws InterruptedException
    {
        Thread.sleep(10000);
        System.out.println(“Dear Students");
    }
}
Explanation : In the above program, by using throws keyword we
Output: handled the InterruptedException and we will get the output as
Dear Students
Dear Students
Throws Keyword (Using try-catch)
17

// Java program to demonstrate working of throws

class ThrowsExecp
{
    static void fun() throws IllegalAccessException
    {
        System.out.println("Inside fun(). ");
        throw new IllegalAccessException("demo");
    }
    public static void main(String args[])
    {
        try
Ouput:
        {
Inside fun().
            fun();
caught in main.
        }
        catch(IllegalAccessException e)
        {
            System.out.println("caught in main.");
        }
    }
}
Finally Block
18

• The finally keyword is used in association with a try-catch block and

guarantees that a section of code will be executed, even if an exception
is thrown.

• The finally block will be executed after the try and catch blocks, but
before control transfers back to its origin.

• finally block will execute whether an exception occurs or not or

whether corresponding catch block found or not.
Finally Block (Example-1)
19

// Java program to illustrate finally in // Case where exceptions do not // occur in the program
class B
{
t he p rogram
    public static void main(String[] args)
o no t o ccur in
ns d
    { Exceptio
        int k = 55;
        try
{
            System.out.println("In try block");
            int z = k / 55;
Output:
        }
  
In try block
        catch (ArithmeticException e) Executes whether exception occurs or not
{
            System.out.println("In catch block");
            System.out.println("Dividing by zero but caught");
        }
        finally
        {
            System.out.println("Executes whether exception occurs or not");
        }
    }
}
Finally Block (Example-2)
20

// Java program to illustrate finally // Case where exceptions occur // and match in the program
class C
{ s po nding
    public static void main(String[] args) an d corre
n o cc urs
    {
Ex c eptio m atches
        int k = 66;
a tch block
        try { c
            System.out.println("In try block");
            int z = k / 0;
            // Carefully see flow dosen't come here
            System.out.println("Flow dosen't came here");
        }
  
Output:
        catch (ArithmeticException e) {
            System.out.println("In catch block"); In try block
            System.out.println("Dividing by zero but caught"); In catch block
        } Dividing by zero but caught
   Finally block, Executes whether an exception occurs or not
        finally
        {
            System.out.println(“Finally block, Executes whether an exception occurs or not");
        }
    }
}
Common Scenarios where Exceptions may Occur

ArithmeticException occurs
int a=50/0; //ArithmeticException

NullPointerException occurs
String s=null;
System.out.println(s.length()); //NullPointerException

NumberFormatException occurs
String s="abc";
int i=Integer.parseInt(s); //NumberFormatException

ArrayIndexOutOfBoundsException occurs
int a[]=new int[5];
a[10]=50; //ArrayIndexOutOfBoundsException
User-defined Exceptions
If we can create your own exceptions in Java. Then, keep the following points in mind when writing your
own exception classes.

• All exceptions must be a child of Throwable.

• If you want to write a checked exception that is automatically enforced by the Handle or Declare
Rule, you need to extend the Exception class.

• If you want to write a runtime exception, you need to extend the RuntimeException class.

• For example, we can define our own Exception class as below: class MyException extends Exception{ }
 User-defined Exception (Example)
/* This is my Exception class, I have named it MyException * you class Example1
can give any name, just remember that it should * extend {
Exception class */ public static void main(String args[])
{
class MyException extends Exception
try
{
String str1; { System.out.println("Starting of try block");
/* Constructor of custom exception class * here I am copying // I'm throwing the custom exception using throw
the message that we are passing while * throwing the throw new MyException("This is My error Message");
exception to a string and then displaying * that string along }
with the message. */ catch(MyException exp)
{
MyException(String str2) System.out.println("Catch Block") ;
{ str1=str2; }
System.out.println(exp) ;
public String toString()
{ return ("MyException Occurred: "+str1) ; } }
} } Output:
} Starting of try block
Catch Block
MyException Occurred: This is My error
Message
References
24

• https://www.geeksforgeeks.org/exceptions-in-java/
• https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/
• https://www.geeksforgeeks.org/throw-throws-java/
• https://www.geeksforgeeks.org/types-of-exception-in-java-with-examples/
• https://beginnersbook.com/2013/04/java-checked-unchecked-exceptions-with-examples/
• https://www.journaldev.com/1696/exception-handling-in-java
• https://www.geeksforgeeks.org/g-fact-24-finalfinally-and-finalize-in-java/