Modern Programming Tools And

Techniques-I

Lecture 14: Exception Handling

Lovely Professional University, Punjab

Exception
 Introduction
• An exception is an event, which occurs during the execution of a
program, that disrupts the normal flow of the program's
instructions.

• A Java exception is an object that describes an exceptional (that

is, error) condition that has occurred in a piece of code.

• An exception is an abnormal condition that arises in a code

sequence at run time.

• In other words, an exception is a run-time error.

Exception Handling
 Exception Handling

• An Exception is a run-time error that can be handled

programmatically in the application and does not result in
abnormal program termination.

• Exception handling is a mechanism that facilitates

programmatic handling of run-time errors.

• In java, each run-time error is represented by an object.

Modified example
 Exception (Class Hierarchy)
• At the root of the class hierarchy, there is an abstract class named
‘Throwable’ which represents the basic features of run-time errors.

• There are two non-abstract sub-classes of Throwable.

• Exception : can be handled
• Error : can’t be handled

• RuntimeException is the sub-class of Exception.

• Exceptions of this type are automatically defined for the programs

that we write and include things such as division by zero and invalid
array indexing.

• Each exception is a run-time error but all run-time errors are not
exceptions.
 Throwable

Exception Error

Run-time Exception - VirtualMachine

• IOEXception - ArithmeticException - NoSuchMethod
• SQLException - ArrayIndexOutOf - StackOverFlow
BoundsException
- NullPointerException

Checked Exception
Unchecked Exception
 Checked Exception
• Checked Exceptions are those, that have to be either caught or
declared to be thrown in the method in which they are raised.
• It is a reminder by compiler to programmer to handle failure
senarios.
• When to use:
– Operation where chances of failure are more eg: IO operation, database
access, networking operation, etc.
 Unchecked Exception
• Those exceptions whose handling is not verified during
compile-time.
• It is direct sub-class of RuntimeException.
• Advantage: maintains code readability.
• They arise due to:
– Programming errors (like accessing method of null object, accessing
element outside array)
 Hierarchy of exception classes
Un-checked exceptions
 Commonly used sub-classes of Exception
• ArithmeticException

• ArrayIndexOutOfBoundsException

• NumberFormatException

• NullPointerException

• IOException
 Commonly used sub-classes of Errors
• VirtualMachineError

• StackOverFlowError

• NoClassDefFoundError

• NoSuchMethodError
 Uncaught Exceptions
class Exception_Demo
{
public static void main(String args[])
{
int d = 0;
int a = 42 / d;
}
}

• When the Java run-time system detects the attempt to divide by

zero, it constructs a new exception object and then throws this
exception.
• once an exception has been thrown, it must be caught by an
exception handler and dealt with immediately.
• In the previous example, we haven’t supplied any exception
handlers of our own.

• So the exception is caught by the default handler provided by the

Java run-time system.

• Any exception that is not caught by your program will ultimately be

processed by the default handler.

• The default handler displays a string describing the exception, prints

a stack trace from the point at which the exception occurred, and
terminates the program.

java.lang.ArithmeticException: / by zero at Exc0.main(Exc0.java:4)

 Why Exception Handling?
• When the default exception handler is provided by the Java
run-time system , why Exception Handling?

• Exception Handling is needed because:

– it allows to fix the error, customize the message .
– it prevents the program from automatically terminating
Exception Handling
 Keywords for Exception Handling

• try
• catch
• throw
• throws
• finally
 Keywords for Exception Handling

try
• used to execute the statements whose execution may result in
an exception.

try {
Statements whose execution may cause an exception
}

Note: try block is always used either with catch or finally or with
both.
 Keywords for Exception Handling

catch
• catch is used to define a handler.

• It contains statements that are to be executed when the

exception represented by the catch block is generated.

• If program executes normally, then the statements of catch

block will not executed.

• If no catch block is found in program, exception is caught by

JVM and program is terminated.
class Divide{
public static void main(String arr[]){
try {
int a= Integer.parseInt(arr[0]);
int b= Integer.parseInt(arr[1]);
int c = a/b;
System.out.println(“Result is: ”+c);
}
catch (ArithmeticException e)
{System.out.println(“Second number must be non-zero”);}

catch (NumberFormatException n)
{System.out.println(“Arguments must be Numeric”);}

catch (ArrayIndexOutOfBoundsException a)
{System.out.println(“Invalid Number of arguments”);}
}
}
 Nested Try’s
class NestedTryDemo {
public static void main(String args[]){
try {
int a = Integer.parseInt(args[0]);
try {
int b = Integer.parseInt(args[1]);
System.out.println(a/b);
}
catch (ArithmeticException e)
{
System.out.println(“Div by zero error!");
}
}
catch (ArrayIndexOutOfBoundsException) {
System.out.println(“Need 2 parameters!");
}
}}
Exception thrown by called function
 Defining Generalized Exception Handler

• A generalized exception handler is one that can handle the

exceptions of all types.

• If a class has a generalized as well as specific exception

handler, then the generalized exception handler must be the
last one.
class Divide{
public static void main(String arr[]){
try {
int a= Integer.parseInt(arr[0]);
int b= Integer.parseInt(arr[1]);
int c = a/b;
System.out.println(“Result is: ”+c);
}
catch (Throwable e)
{
System.out.println(e);
}
}
}
 Keywords for Exception Handling
throw
• used for explicit exception throwing.
throw(Exception obj);

‘throw’ keyword can be used:

• to throw user defined exception
• to customize the message to be displayed by predefined exceptions
• to re-throw a caught exception

• Note: System-generated exceptions are automatically thrown by

the Java run-time system.
class ThrowDemo
{
static void demo()
{
try {
throw new NullPointerException("demo");
}
catch(NullPointerException e)
{
System.out.println("Caught inside demo.");
throw e; // rethrow the exception
}
}
public static void main(String args[])
{
try {
demo();
}
catch(NullPointerException e)
{
System.out.println("Recaught: " + e);
}
}
}
Example
 Keywords for Exception Handling
throws
• A throws clause lists the types of exceptions that a method might
throw.
type method-name(parameter-list) throws exception-list
{
// body of method
}
• 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.
import java.io.*;
public class ThrowsDemo
{
public static void main( String args []) throws IOException
{
char i;
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter character, 'q' to quit");
do{
i = (char) br.read();
System.out.print(i);
}while(i!='q');
}
}
Example of “throws” keyword
 Keywords for Exception Handling

Finally
• finally creates a block of code that will be executed after a
try/catch block has completed and before the code following
the try/catch block.

• The finally block will execute whether or not an exception is

thrown.

• If an exception is thrown, the finally block will execute even

if no catch statement matches the exception.
• If a finally block is associated with a try, the finally block will
be executed upon conclusion of the try.

• The finally clause is optional. However, each try statement

requires at least one catch or a finally clause.
Example
 Defining Custom Exceptions
• We can create our own Exception sub-classes by inheriting
Exception class.

• The Exception class does not define any methods of its own.

• It inherits those methods provided by Throwable.

• Thus, all exceptions, including those that we create, have the

methods defined by Throwable available to them.
 Constructor for creating Exception

• Exception( )
• Exception(String msg)

• A custom exception class is represented by a subclass of

Exception / Throwable.

• It contains the above mentioned constructor to initialize

custom exception object.
class Myexception extends Throwable
{
public Myexception(int i)
{
System.out.println("you have entered ." +i +" : It
exceeding the limit");
}
}
public class ExceptionTest {
public void show(int i) throws Myexception
Here object of custom class
{ is created and thrown
if(i>100)
throw new Myexception(i);
else
System.out.println(+i+" is less then 100 it is ok");
}
public static void main(String []args){
int i=Integer.parseInt(args[0]);
int j=Integer.parseInt(args[1]);
ExceptionTest t=new ExceptionTest();
try{
t.show(i); t.show(j);
}
catch(Throwable e) {
System.out.println("catched exception is "+e);
}
}
}
Custom/ user-defined
exception