L14 exception handling

Programming in Java
Lecture 14: Exception Handling

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
class Exception
{
public static void main (String arr[])
{
System.out.println(“Enter two numbers”);
Scanner s = new Scanner (System.in);
int x = s.nextInt();
int y = s.nextInt();
int z = x/y;
System.out.println(“result of division is : ” + z);
}
}

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.

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.
Unchecked Exception
• Unchecked Exceptions are those that are not forced by the
compiler either to be caught or to be thrown.
• Unchecked Exceptions either represent common programming
errors or those run-time errors that can’t be handled through
exception handling.

Commonly used sub-classes of Exception
• ArithmeticException
• ArrayIndexOutOfBoundsException
• NumberFormatException
• NullPointerException
• IOException

Commonly used sub-classes of Errors
• VirualMachineError
• 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

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

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.

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!");
}
}}

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);
}
}
}

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);
}
}
}

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');
}
}

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.

Chained Exceptions
• Throwing an exception along with another exception forms a
chained exception.

Chained Exceptions
public class ChainedExceptionDemo {
public static void main(String[] args) {
try { method1(); }
catch (Exception ex) { ex.printStackTrace();} }
public static void method1() throws Exception {
try { method2(); }
catch (Exception ex) {
throw new Exception("New info from method1”, ex); } }
public static void method2() throws Exception {
throw new Exception("New info from method2");
} }

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 {
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);
}
}
}

L14 exception handling

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to L14 exception handling (20)

More from teach4uin (20)

Recently uploaded (20)

L14 exception handling