Exception

Exception
• An exception is an abnormal condition that
arises in a code sequence at run time.
• An exception is a run time error

• A Java exception is an object that
describes an exceptional (that is, error)
condition that has occurred in a piece of
code
• When an exceptional condition arises, an
object representing that exception is
created and thrown in the method that
caused the error
• That method maychoose to handle it self
or pass it on.
• At some point the exception is caught and
processed

• Exceptions can be generated by java run
time system or can be manually generated
by your code.
• JRE generates exceptions when you
violate the rules of java language or the
constraints of java execution environment.
• Manually generated exceptions are
typically used to report some error
condition to the caller of a method.

• Java exception handling is managed via five
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 the try block, it is
thrown
• Your code can catch this exception (using
catch) and handle it

• System-generated exceptions are automatically
thrown by the Java run-time system
• To manually throw an exception, use the
keyword throw
• Any exception that is thrown out of a method
must be specified as such by a throws clause
• Any code that absolutely must be executed
before a method returns is put in a finally block

• This is the general form of an exception-handling block:
try {
// block of code to monitor for errors
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType2
}
// ...
finally {
// block of code to be executed before try block ends
}

Exception Types
• All exception types are subclasses of the built-in
class Throwable
• Immediately below Throwable are two
subclasses that partition exceptions into two
distinct branches
• One branch is headed by Exception
• This class is used for exceptional conditions that
user programs should catch

• There is an important subclass of
Exception, called RuntimeException
• Exceptions of this type are automatically
defined for the programs that you write
and include things such as division by
zero and invalid array indexing

• The other branch is topped by Error, which
defines exceptions that are not expected to be
caught under normal circumstances by your
program
• Exceptions of type Error are used by the Java
run-time system to indicate errors having to do
with the run-time environment, itself
• Stack overflow is an example of such an error

Uncaught Exceptions
• class Exc0 {
• public static void main(String args[]) {
• int d = 0;
• int a = 42 / d;
• }
• }
• Java.lang.ArithmeticException: /by zero at
Exc0.main(Exco.java:4)

• When JRE detects the attempt to /0 it
constrcucts a new exception object and throws
this exception
• This causes the execution of Exc0 to stop
because once an exception is generated it
should be caught some where.In this case we
have not supplied any handler so default handler
of JRE gets called.
• Default handler displays string describing the
exception and the stack trace from the point at
which exception has occurred and terminates
the program.

• class Exc1 {
• static void subroutine() {
• int d = 0;
• int a = 10 / d;
• }
• Exc1.subroutine();
• }
• }

• Java.lang.ArithmeticException: /by zero
• at Exc1.subroutine(Exc1.java:4)
• at Exc1.main(Exc1.java:7)

Using try and catch
• Handling an exception manually provides
two benefits
• First, it allows you to fix the error
• Second, it prevents the program from
automatically terminating

class Exc2 {
public static void main(String args[]) {
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero
error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
} o/p:
This program generates the following output:
Division by zero.

• A try and its catch statement form a unit
• The scope of the catch clause is restricted
to those statements specified by the
immediately preceding try statement
• A catch statement cannot catch an
exception thrown by another try statement

// Handle an exception and move on.
import java.util.Random;
class HandleError {
int a=0, b=0, c=0;
Random r = new Random();
for(int i=0; i<32000; i++) {
try {
b = r.nextInt();
c = r.nextInt();
a = 12345 / (b/c);
} catch (ArithmeticException e) {
System.out.println("Division by zero.");
a = 0; // set a to zero and continue
}
System.out.println("a: " + a);
}
}
}

Displaying a Description of an
Exception
catch (ArithmeticException e) {
System.out.println("Exception: " + e);
a = 0; // set a to zero and continue
}
Exception: java.lang.ArithmeticException: /
by zero

Multiple catch Clauses
// Demonstrate multiple catch statements.
class MultiCatch {
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

• Java MultiCatch
• a=0
• Divide by 0:java.lang.ArithmeticException:/by zero
• After try/catch blocks
OR
• Java MultiCatch TestArg
• a=1
• Array index
oob:java.lang.ArrayIndexOutOfBoundsException:42
• After try/catch blocks

/* This program contains an error. A subclass must come
before its superclass in a series of catch statements. If
not, unreachable code will be created and a compile-
time error will result. */
class SuperSubCatch {
try {
int a = 0;
int b = 42 / a;
} catch(Exception e) {
System.out.println("Generic Exception catch.");
}
/* This catch is never reached because ArithmeticException
is a subclass of Exception. */
catch(ArithmeticException e) { // ERROR - unreachable
System.out.println("This is never reached.");
}
}

Nested try Statements
• Each time a try statement is entered, the
context of that exception is pushed on the
stack

• // An example nested try statements.
• class NestTry {
• try {
• int a = args.length;
• /* If no command line args are present,
• the following statement will generate
• a divide-by-zero exception. */
• int b = 42 / a;
• System.out.println("a = " + a);
• try { // nested try block
• /* If one command line arg is used,
• then an divide-by-zero exception
• will be generated by the following code. */

• if(a==1) a = a/(a-a); // division by zero
• /* If two command line args are used
• then generate an out-of-bounds exception. */
• if(a==2) {
• int c[] = { 1 };
• c[42] = 99; // generate an out-of-bounds exception
• }
• } catch(ArrayIndexOutOfBoundsException e) {
• System.out.println("Array index out-of-bounds: " + e);
• }
• } catch(ArithmeticException e) {
• System.out.println("Divide by 0: " + e);
• }
• }
• }

• /* Try statements can be implicitly nested via
• calls to methods. */
• class MethNestTry {
• static void nesttry(int a) {
• try { // nested try block
• /* If one command line arg is used,
• then an divide-by-zero exception
• will be generated by the following code. */
• if(a==1) a = a/(a-a); // division by zero
• /* If two command line args are used
• then generate an out-of-bounds exception. */
• if(a==2) {
• int c[] = { 1 };
• c[42] = 99; // generate an out-of-bounds exception
• }
• } catch(ArrayIndexOutOfBoundsException e) {

• System.out.println("Array index out-of-bounds: " + e);
• }
• }
• try {
• int a = args.length;
• /* If no command line args are present,
• the following statement will generate
• a divide-by-zero exception. */
• int b = 42 / a;
• System.out.println("a = " + a);
• nesttry(a);
• } catch(ArithmeticException e) {
• System.out.println("Divide by 0: " + e);
• }
• }
• }

throw
• It is possible for your program to throw an
exception explicitly, using the throw
statement
• The general form of throw is shown here:
throw ThrowableInstance;

• Here, ThrowableInstance must be an
object of type Throwable or a subclass of
Throwable
• There are two ways you can obtain a
Throwable object: using a parameter into
a catch clause, or creating one with the
new operator
• The flow of execution stops immediately
after the throw statement; any
subsequent statements are not executed

// Demonstrate throw.
class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
throw e; // rethrow the exception
}
}
try {
demoproc();
} catch(NullPointerException e) {
System.out.println("Recaught: " + e);
} } }
Output:
Caught inside demoproc.
Recaught: java.lang.NullPointerException: demo

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
• A throws clause lists the types of exceptions
that a method might throw

• Exceptions that a method can throw must be
declared in the throws clause
• This is the general form of a method declaration
that includes a throws clause:
type method-name(parameter-list) throws
exception-list
{
// body of method
}
• Here, exception-list is a comma-separated list of
the exceptions that a method can throw

// This program contains an error and will
not compile.
class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[ ]) {
throwOne();
}
}

class ThrowsDemo {
static void throwOne() throws IllegalAccessException {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
try {
throwOne();
} catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
}
}
Here is the output generated by running this example
program:
inside throwOne

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

• The finally clause is optional
• Each try statement requires at least one
catch or a finally clause

// Demonstrate finally.
class FinallyDemo {
// Through an exception out of the method.
static void procA() {
try {
System.out.println("inside procA");
throw new RuntimeException("demo");
} finally {
System.out.println("procA's finally");
}
}
// Return from within a try block.
static void procB() {
try {
System.out.println("inside procB");
return;
} finally {
System.out.println("procB's finally");
}
}

// Execute a try block normally.
static void procC() {
try {
System.out.println("inside procC");
} finally {
System.out.println("procC's finally");
}
}
try {
procA();
} catch (Exception e) {
System.out.println("Exception caught");
}
procB();
procC();
}
}

Here is the output generated by the
preceding program:
inside procA
procA’s finally
Exception caught
inside procB
procB’s finally
inside procC
procC’s finally

Creating our own Exception
subclasses
• // This program creates a custom exception type.
• class MyException extends Exception {
• private int detail;
• MyException(int a) {
• detail = a;
• }
• public String toString() {
• return "MyException[" + detail + "]";
• }
• }
• class ExceptionDemo {
• static void compute(int a) throws MyException {
• System.out.println("Called compute(" + a + ")");

Creating our own Exception
subclasses
• if(a > 10)
• throw new MyException(a);
• System.out.println("Normal exit");
• }
• try {
• compute(1);
• compute(20);
• } catch (MyException e) {
• System.out.println("Caught " + e);
• }
• }
• }

• Called compute(1)
• Normal exit
• Called compute(20)
• Caught MyException[20]

Exception

More Related Content

What's hot (13)

Viewers also liked (20)

Similar to Exception (20)

More from Tony Nguyen (20)

Recently uploaded (20)

Exception