Topics

• More features of Java :

Exception Handling:

• Checked Exceptions

• Unchecked Exceptions

• try Block and catch Clause

Prepared by Renetha J.B. 2

 Exception Handling
• An exception is an abnormal condition that occur in a code
sequence at run time.
– Exception is a RUN TIME ERROR
• A Java exception is an object that describes an exceptional
(that is, error) condition that occurred in a piece of code.
• When an exceptional condition arises,
– an object representing that exception is created and
– It is thrown in the method that caused the error.
• That method may choose to handle the exception itself,
or pass it on.
• The exception is then caught and processed

Prepared by Renetha J.B. 3

 Exception Handling(contd.)

• Exceptions can be generated by

– the Java run-time system, or

– they can be manually generated by your code.

• Exceptions thrown by Java are related to

– Fundamental errors that violate the rules of

• the Java language or

• the constraints of the Java execution environment.

4
Prepared by Renetha J.B.
 Exception Types
• All exception types are subclasses of the built-in
class Throwable.
• Throwable has 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. Subclass of
this helps to create custom exception types.
• RuntimeException is a subclass of
Exception.
The other branch is headed by Error
• This defines exceptions that are not expected to be caught
under normal circumstances by our program.(unchecked)
• Exceptions of type Error are used by the Java run-time
system to indicate errors.
E.g. Stack overflow,Out of Memory error 5
Prepared by Renetha J.B.
 EXCEPTION

CHECKED EXCEPTIONS UNCHECKED EXCEPTIONS

Prepared by Renetha J.B. 6

 Unchecked exception
• Unchecked exception classes are defined inside
java.lang package.
– The unchecked exceptions are subclasses of
the standard type RuntimeException.

– In the Java language, these are called

unchecked exceptions because the compiler
does not check to see whether there is a method
that handles or throws these exceptions.
– If the program has unchecked exception then it
will compile without error but exception occurs
when program runs.

•E.g Exceptions under Error , ArrayIndexOutOfBoundException 7

Prepared by Renetha J.B.
 Unchecked exception(contd.)
• The unchecked exceptions defined in java.lang are

8
Prepared by Renetha J.B.
 Checked exception
• There are some exceptions that are defined by java.lang that
must be included in a method’s throws list, if a method
generates such exceptions and that method does not handle it
itself. These are called checked exceptions

• IOException
• FileNotFoundException
• SQLException
Prepared by Renetha J.B. 9
 Checked exception(contd.)

• Checked exceptions are the exceptions (in java.lang) that

are checked at compile time.
– If some statement in a method throws a checked
exception, then that method must

• either handle the exception or

• it must specify the exception using throws keyword.

Prepared by Renetha J.B. 10

 Checked exceptions Unchecked exceptions
• Checked at compile • NOT checked at compile
time.(COMPILE TIME time.(RUN TIME
EXCEPTIONS) EXCEPTINS)
• Not sub class of • Sub class of
RunTimeException RunTimeException
• The method must either • It is NOT needed to handle
handle the exception or it or catch these exceptions
must specify the exception
using throws keyword.
• DO NOT Show compile
• Shows compile error if error if exception is not
checked exception is not handled. But shows run-
handled. time error.
• E.g. ClassNotFoundException, • Eg. ArithmeticException,
IOException ArrayIndexOutOfBoundsException
11
Prepared by Renetha J.B.
Exception handling fundamentals

try

finally catch
Java exception
handling is
managed via
FIVE
keywords:

throws throw

Prepared by Renetha J.B. 12

Exception handling fundamentals(contd.)

• Program statements that we want to check for exceptions are

written within a try block.
– If an exception occurs within the try block, it is thrown.
– The code inside catch can catch this exception and handle
it in some manner.
• 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 after a try block
completes is put in a finally block.
Prepared by Renetha J.B. 13
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 after try block ends
} Prepared by Renetha J.B.
14
Here, ExceptionType is the type of exception that has occurred.
 Uncaught Exceptions
• Consider the program
Lineno.1 class Ex{
Lineno.2 public static void main(String args[])
Lineno.3 { int d = 0;
Lineno.4 int a = 42 / d;
Lineno.5 }
Lineno.6 }
• This small program causes a divide-by-zero error((42/0)
• Java run time system constructs a new exception object and
then throws this exception.
• Th erogram stops by showing the following exception(run time
erroe)
• java.lang.ArithmeticException: / by zero at Ex.main(Ex.java:4)
Prepared by Renetha J.B.
15
• java.lang.ArithmeticException: / by zero at
Ex.main(Ex.java:4)

• Here Ex is the class name , main is the method name,;

Ex.java is the file name; and the exception is inline number 4.
• These details are all included in the simple stack trace.
• The type of exception thrown is a subclass of Exception called
ArithmeticException (describes what type of error
happened.)

Prepared by Renetha J.B. 16

Prepared by Renetha J.B. 17
Lineno.1 class Exc1 {
Lineno.2 static void subroutine()
Lineno.3 { int d = 0;
Lineno.4 int a = 10 / d;
Lineno.5 }
Lineno.6 public static void main(String args[])
Lineno.7 { Exc1.subroutine();
Lineno.8 }
Lineno.9 }
• java.lang.ArithmeticException: / by zero
at Exc1.subroutine(Exc1.java:4)
at Exc1.main(Exc1.java:7)

Prepared by Renetha J.B. 18

 try Block and catch Clause
• Benefits of exception handling
– First, it allows us to fix the error.

– Second, it prevents the program from automatically

terminating.

• To guard against and handle a run-time error, simply

enclose the code that we want to monitor inside a try block.

• Immediately after the try block, there is a catch clause that

specifies the exception type that we wish to catch . The catch
block can process that exception..
19
Prepared by Renetha J.B.
class Exc2{
public static void main(String args[])
{ try
{
int d = 0;
int a = 42 / d;
}
catch(ArithmeticException ae)
{
System.out.println("Division by Zero not allowed");
}
}
}

Prepared by Renetha J.B. 20

class Exc2{
public static void main(String args[])
{ try
{
int d = 0;
int a = 42 / d;
}
catch(ArithmeticException ae)
{
System.out.println("Division by Zero not allowed");
}
}
}

Prepared by Renetha J.B. 21

Prepared by Renetha J.B. 22
try-catch block to handle division by zero exception
class Ex {
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."); OUTPUT
} Division by zero.
After catch statement.
System.out.println("After catch statement.");
}
}
Prepared by Renetha J.B. 23
 Working of the program

• In this program the System.out.println("This will not be printed.");

inside the try block is never executed because a = 42 / d;

• Once an exception is thrown, program control transfers out of

the try block into the catch block.

• i.e. catch is not “called” but controls goes out to catch when
exception occurs, so execution never “returns” to the try
block from a catch.

• Thus, the line “This will not be printed.” is not displayed.

Prepared by Renetha J.B. 24
 try-catch (contd.)

• 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.
– Each catch block can catch exceptions in statements inside
immediately preceding try block.

• A catch statement cannot catch an exception thrown by another

try statement (except in the case of nested try statements).
• The statements that are protected by try must be surrounded by
curly braces. (That is, they must be within a block.)
• We cannot use try on a single statement

Prepared by Renetha J.B. 25

 try-catch Example
import java.util.Random;
class HandleError {
public static void main(String args[]) {
int a=0, b=0, c=0;
Here b and c are random numbers .
Random r = new Random();
If the value of b or c becomes zero then
for(int i=0; i<32000; i++) { a=12345./ (b/c) becomes
try { a=12345/0;
b = r.nextInt(); (Division by zero(ArithmeticException) will
occur)
c = r.nextInt();
This statement is inside try block
a = 12345 / (b/c);
So exception will be caught by catch and
} prints message Division by zero.
catch(ArithmeticException e) and set the value of a to 0 and proceeds
{ NO RUNTIME ERROR!!
System.out.println("Division by zero.");
a = 0; // set a to zero and continue
}
System.out.println("a: " + a);
}}} Prepared by Renetha J.B. 26
Displaying a Description of an Exception
• We can display this description in a println( ) statement by simply
passing the exception as an argument.
class Exc3{
public static void main(String args[])
{ try
{
int d = 0;
int a = 42 / d;
}
catch(ArithmeticException ae)
{
System.out.println("The exception occurred is "+ae);
}
}
}
Prepared by Renetha J.B. 27
Prepared by Renetha J.B. 28
 Topics

• More features of Java :

Exception Handling:

• Multiple catch Clauses

• Nested try Statements

Prepared by Renetha J.B. 2

 Multiple catch Clauses
• There can be more than one exception in a single piece of
code.

– To handle this type of situation, we can specify two or more

catch clauses, each catching a different type of exception.

• When an exception is thrown,

– each catch statement is inspected in order, and

– the first one whose type matches that of the exception is executed.

• After one catch statement executes, the other catch statements

are bypassed(ignored), and execution continues after the
try/catch block. 3
Prepared by Renetha J.B.
 Multi catch-Example
class Multicatch {
public static void main(String args[]) {
try {
int a = args.length; //number of commandline arguments
System.out.println("a = " + a);
int b = 42 / a; //when a is 0 this will raiseAthmeticException
int c[] = { 1 };
c[42] = 99; //size of array is 1. So c[42] leds to ArrayIndexOutOfBoundsException
Here the value of a is set as the number of
} command line arguments. If no command
catch(ArithmeticException e) line arguments are there during execution
E.g. java MultiCatch
{ Here a is 0
So int b = 42 / a; will cause
System.out.println("Divide by 0: " + e); ArithmeticException. and is caught by
} catch(ArithmeticException e).

catch(ArrayIndexOutOfBoundsException e) If command line arguments are there ,then a

is not zero. E.g. java MultiCatch ok
{ (Here a=1. So no exception occurs in int b
System.out.println("Array index oob: " + e); = 42 / a )
Size of array c is1 (only one element).
} So c[42] = 99; will cause
ArrayIndexOutofBoundsException
System.out.println("After try/catch blocks."); occurs(because position 42 is not there in
this array)
}
Prepared by Renetha J.B. 4
}
• Output

Prepared by Renetha J.B. 5

 Multi-catch (contd.)

• When we use multiple catch statements, it is important

that exception subclasses must come before any of their
superclasses.

• If we are using catch with superclass exception before the

catch with subclass exception then catch with subclass
exception will be ignored.
– Such codes are unreachable. Unreachable code is an
ERROR.

Prepared by Renetha J.B. 6

• E.g. Exception class is the superclass of all other exception classes
like ArithmeticException, FileNotFoundException etc.
try
{
//statements
}
catch(Exception e) //ALL EXCEPTIONS WIL BE CAUGHT HERE
{ //statements
}
catch(ArithmeticException ae) //This catch is never used for catching
{//statements
}
Any exception that occurs in try block will be caught by the first suitable
catch. Here all exceptions will match with Exception object. So even
though ArithmeticExcepton occurs inside try block, it will be caught by
catch(Exception e) block. So catch(ArithmeticException ae) will never
catch it. Prepared by Renetha J.B. 7
Multi catch(ERROR) // superclassexception should not be caught before catching subclass
class SuperSubCatch {
public static void main(String args[])
{
try {
int a = 0;
int b = 42 / a;
}
catch(Exception e) //All exceptions are caught here
{System.out.println("Generic Exception catch.");
}
/* The next catch is never reached because
ArithmeticException is a subclass of Exception. */
catch(ArithmeticException e)
{ // ERROR - unreachable
System.out.println(“ Arithmetic Exception occurred ");
}
}
}
COMPILE ERROR- the second catch statement is unreachable because the
exception has already been caught by Exception 8
Prepared by Renetha J.B.
 A subclass must come before its superclass in a series of catch statements.
class SuperSubCatch {
public static void main(String args[])
{
try {
int a = 0;
int b = 42 / a;
}
catch(ArithmeticException e)
{
System.out.println(" Arithmetic Exception occurred ");
}
catch(Exception e)
{System.out.println("Generic Exception catch.");
}
}
}
This is the correct usage of catch. The catch with subclass
exception(AritnmeticException) should appear before catch with super class
exception(Exception) 9
Prepared by Renetha J.B.
 Nested try Statements

• The try statement can be nested.

– A try statement can be inside the block of another try.
• Each time a try statement is entered, the context of that
exception is pushed on the stack.
– If an inner try statement does not have a catch handler for a
particular exception, the stack is unwound and the next try
statement’s catch handlers are inspected for a match.
– This continues until one of the catch statements succeeds, or
until all of the nested try statements are exhausted.
– If no catch statement matches, then the Java run-time system
will handle the exception.

Prepared by Renetha J.B. 10

class NestTry {
public static void main(String args[]) {
C:\>java NestTry
try { Divide by 0: java.lang.ArithmeticException: / by zero
int a = args.length; C:\>java NestTry One
int b = 42 / a; a=1
System.out.println("a = " + a); Divide by 0: java.lang.ArithmeticException: / by zero
C:\>java NestTry One Two
try {
a=2
if(a==1) a = a/(a-a); // division by zero Array index out-of-bounds:
if(a==2) java.lang.ArrayIndexOutOfBoundsException:42
{ int c[] = { 1 };
c[42] = 99; // generate an out-of-bounds exception
} When we execute the program with no command-
} catch(ArrayIndexOutOfBoundsException e) { line arguments, a divide-by-zero exception is
System.out.println("Array index out-of-bounds: " + e); generated by the outer try block.
} Execution of the program with one command-line
} argument generates a divide-by-zero exception
from within the nested try block.
catch(ArithmeticException e) {
Since the inner block does not catch this exception,
System.out.println("Divide by 0: " + e); it is passed on to the outer try block, where it is
} handled.
} If you execute the program with two command-line
} arguments, an array boundary exception is
generated from within the inner try block.
11
Prepared by Renetha J.B.
 Nested try(contd.)

• We can enclose a call to a method within a try block.

– Inside that method we can have another try statement.

• In this case, the try within the method is still nested inside the
outer try block, which calls that method.

Prepared by Renetha J.B. 12

class MethNestTry {
static void show(int a) {
try { // nested try block
Here try in main function act as outer try block.
if(a==1) a = a/(a-a); // division by zero Inside that try show() function is called . So try
if(a==2) { catch inside show() function is inner to the try in
main function.
int c[] = { 1 };
c[42] = 99; // generate an out-of-bounds exception When we execute the program with no command-
} line arguments, a divide-by-zero exception is
} catch(ArrayIndexOutOfBoundsException e) { generated by the outer try block and is caught by
System.out.println("Array index out-of-bounds: " + e); outer catch clause(matching is there).
Execution of the program with one command-line
}
argument generates a divide-by-zero exception
} from within the try block in show().
public static void main(String args[]) { Since the inner catch(no matching) block does not
try { catch this exception, it is passed on to the outer try
int a = args.length; block in main function(matching is there) , and it is
int b = 42 / a; handled.
System.out.println("a = " + a);
show(a);// show contains a try – catch . So nested try.
If we execute the program with two command-line
} catch(ArithmeticException e) { arguments, an array boundary exception is
System.out.println("Divide by 0: " + e); generated from within the inner try block and is
} caught by innercatch inside show
} Prepared by Renetha J.B. 13
}
 Topics

• More features of Java :

Exception Handling:

• throw

• throws

• finally

Prepared by Renetha J.B. 2

 throw statement
• Our program can throw an exception explicitly, using the
throw statement.

• The general form of throw is shown here:

throw ThrowableInstance;

– ThrowableInstance must be an object of type Throwable or a

subclass of Throwable.

– Primitive types, such as int or char, as well as non-Throwable

classes, such as String and Object, cannot be used as exceptions.

Prepared by Renetha J.B. 3

 throw(contd.)

• Two ways to obtain a Throwable object:

1. using a parameter in a catch clause, or

2. creating one with the new operator

Prepared by Renetha J.B. 4

 throw statement(contd..)
• The flow of execution stops immediately after the throw
statement.
– Any statements after throw statement will not be executed.
• When exception is thrown using throw statement :-
– the nearest enclosing try block is inspected to see if it has a
catch statement that matches the type of exception thrown.
• If that catch statement has a matching exception type as
the thrown exception, control is transferred to that
statement.
• If not matching, then the next enclosing try statement is
inspected, and so on.
• If no matching catch is found, then the default exception
handler halts the program and prints the stack trace.
Prepared by Renetha J.B. 5
 throw Example 1
class ThrowDemo
{
static void show()
{
try
{throw new NullPointerException("demoexception");
} Here first throw in show is caught by
catch(NullPointerException e) matching catch is in show function.
{
System.out.println("Caught inside show"); Next throw has no immediate catch
throw e; // rethrow the exception So since the exception matches with
} catch in the main function(that calls
} show), the exception is caught by
public static void main(String args[]) that matching catch in main.
{
try { java ThrowDemo
Caught inside show
show();
Recaught in main: java.lang.NullPointerException: demoexception
}
catch(NullPointerException e)
{ System.out.println("Recaught in main: " + e);
}
Prepared by Renetha J.B. 6
} }
throw with matching catch in calling function
class ThrowDemo2
{
static void show()
{
throw new NullPointerException("demoxception");
}
public static void main(String args[])
{ Here no matching catch for throw is in show function
So since the exception matches with catch in the
try
main function( that calls show), the exception
{ is caught by that matching catch
show();
} catch(NullPointerException e)
{ System.out.println("Caught in main: " + e);
} OUTPUT
} Caught in main: java.lang.NullPointerException: demoexception
}
7
Prepared by Renetha J.B.
 throw with NO matching catch
class ThrowDemo2
{
static void show()
{
throw new NullPointerException("demoxception");
}
public static void main(String args[])
{ Here no matching catch is in show function.
try So since the exception does not matches
with catch in the main function( that calls show)
{ also, the exception is not caught in the program
show(); the default exception handler halts the program
} and prints the stack trace
catch(ArithmeticException e)
{ System.out.println("Caught in main: " + e);
} OUTPUT
Exception in thread "main" java.lang.ArithmeticException: demoxception
} at ThrowDemo2.show(ThrowDemo2.java:3)
} at ThrowDemo2.main(ThrowDemo2.java:9) 8
Prepared by Renetha J.B.
 throw(contd.)
• Many of Java’s built-in run-time exceptions have at least two
constructors:
– one with no parameter and
– one that takes a string parameter.
• When constructor with string parameter is used, the argument
specifies a string that describes the exception.
– This string is displayed when the object is printed using print( )
or println( ).
– It can also be obtained by a call to getMessage( ), which is
defined by Throwable.
throw new NullPointerException("demoxception");
• Here the string demoxception inside the constructor of
NullPointerException is the name of the exception.
Prepared by Renetha J.B. 9
 throws

• A throws clause lists the types of exceptions that a

method(function) might throw.

• throws keyword is used with the method signature(header)

• If a method has an exception and it does not handle that

exception, it must specify this using throws , so that callers of
the method can guard themselves against that exception.

• throws is necessary for all exceptions, except those of type

Error or RuntimeException or any of their subclasses

Prepared by Renetha J.B. 10

 throws (contd.)

• 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.
• General form of a method declaration that includes a
throws clause:
type method-name(parameter-list) throws exception-list
{
// body of method
}

Prepared by Renetha J.B. 11

 throw statement but no throws in method-ERROR
public class ThrowsEg {
static void vote(int age) {
if (age < 18) {
throw new IllegalAccessException("You must be at least 18 years old.");
} else {
System.out.println(“ You can vote!");
}
}
public static void main(String[] args)
{
D:\RENETHAJB\OOP>javac ThrowsEg.java
vote(15); ThrowsEg.java:4: unreported exception java.lang.IllegalAccessException; must be
caught or declared to be thrown
} throw new IllegalAccessException("You must be at least 18 years old.");
} ^
1 error
COMPILE ERROR
This program tries to throw an exception that it
does not catch.
Because the program does not specify a throws clause to declare this
exception to be thrown, the program will not compile. Prepared by Renetha J.B.
Include throws in method and try catch in calling function. 12
 Using throws
public class ThrowsEg {
static void vote(int age) throws IllegalAccessException{
if (age < 18) {
throw new IllegalAccessException("You must be at least 18 years old.");
} else {
System.out.println(“ You can vote!");
}
}
public static void main(String[] args)
{ OUTPUT
try{ Exception: java.lang.ArithmeticException: You must be at least 18 years.
vote(15);
}
catch(Exception e)
{
System.out.println("Exception: "+e);
}
} Prepared by Renetha J.B. 13
}
import java.io.*;
class Sample{
void show() throws IOException{
throw new IOException(“Thrown IO error");
}
}
public class Testthrows{
public static void main(String args[]){
try{
Output
Sample s=new Sample(); Exception handledjava.io.IOException: Thrown IO error
s.show(); Normal program flow

}
catch(Exception e){System.out.println("Exception handled. "+e);}

System.out.println("Normal program flow");

}
}
Prepared by Renetha J.B. 14
 finally
• finally creates a block of code that will be executed after a
try/catch block has completed and before the control goes out
from the try/catch 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 after try block ends
} Prepared by Renetha J.B.
15
 Why finally is needed?
• When exceptions are thrown, execution in a method takes a
nonlinear path and changes the normal flow through the
method.
– Sometime exception causes the method to return
prematurely.
– This may cause problems in some cases.
– E.g a method opens a file upon entry and closes it upon exit, then
we will not want the code that closes the file to be bypassed by
the exception-handling mechanism.
• In such situations the code for closing that file and other
codes that should not be bypassed should be written inside
finally block
• This will ensure that necessary codes are not skipped because
of exception handling.
16
Prepared by Renetha J.B.
 finally(contd.)

• 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.
– Any time a method is about to return to the caller from inside a
try/catch block, (via an uncaught exception or an explicit return
statement). the finally clause is also executed just before the
method returns.
• If a finally block is associated with a try, the finally block
will be executed upon conclusion of the try.
Prepared by Renetha J.B. 17
 finally(contd.)

• The finally clause is optional. However, each try

statement requires at least one catch or a finally clause
try
try try {
{ { //monitor exception
//monitor exception //monitor exception }
} } catch(ExceptionType1 ob)
finally catch(ExceptionType1 ob) {
{ { }
} } catch(ExceptionType2 ob)
{
}
//
finally
{
}

Prepared by Renetha J.B. 18

 finally example
class FinallyTry
{
public static void main(String[] args)
{
try
{ OUTPUT
Exception is java.lang.ArithmeticException: / by zero
int a=5/0; Inside finally
} After try - catch -finally
catch(ArithmeticException ae)
{
System.out.println("Exception is "+ae);
} Here int a=5/0; inside try causes ArithmeticException
finally And it is caught by catch(ArithmeticException ae)
And prints the message
{
Exception is details about exception
System.out.println("Inside finally"); Then it enters finally block and prints Inside finally
} Then it comes out from try catch finally block
and prints the message
System.out.println("After try - catch -finally");
After try - catch -finally
}
} 19
Prepared by Renetha J.B.
 finally example
class FinallyTry
{
public static void main(String[] args)
{
try
OUTPUT
{ Inside finally
int a=5/2; After try - catch -finally
}
catch(ArithmeticException ae)
{
System.out.println("Exception is "+ae);
} Here int a=5/2; inside try does not cause exception
(So it is not caught by catch(ArithmeticException ae)
finally
)
{ Then it enters finally block and prints Inside finally
System.out.println("Inside finally"); Then it comes out from try catch finally block
and prints the message
}
After try - catch -finally
System.out.println("After try - catch -finally");
}
} 20
Prepared by Renetha J.B.
 finally Example

class Sample{ class Finally1

void show(int n) {
{ int c=10; public static void main(String[] args)
try
{
{
System.out.println("inside try"); Sample ob=new Sample();
c=10/n; ob.show(1);
} ob.show(0);
catch(Exception e)
{
System.out.println("Exception caught"+e); System.out.println(“Finished");
} }
}
finally
{
System.out.println("Finally done");
} inside try
} Finally done
inside try
Exception caughtjava.lang.ArithmeticException: / by zero
Finally done
}
Finished
21
Prepared by Renetha J.B.
class FinallyDemo { // Execute a try block normally.
static void procC() {
static void procA() {
try {
try { System.out.println("inside procC");
System.out.println("inside procA"); } finally {
throw new RuntimeException("demo");
System.out.println("procC's finally");
} finally { }
System.out.println("procA's finally"); }
public static void main(String args[]) {
}
try {
} procA();
static void procB() { } catch (Exception e) {
System.out.println("Exception caught");
try {
}
System.out.println("inside procB"); procB();
return; procC(); inside procA
} procA’s finally
} finally {
} Exception caught
System.out.println("procB's finally"); inside procB
} procB’s finally
} inside procC
Prepared by Renetha J.B. 22
procC’s finally
Prepared by Renetha J.B. 23