0% found this document useful (0 votes)
21 views11 pages

Oop L23

The document discusses exception handling in Java using try, catch, throw, throws, and finally. It provides examples of how to throw exceptions explicitly using throw, how to declare exceptions that a method may throw using throws, and how finally blocks are used to ensure code is executed even if an exception occurs or the method returns early.

Uploaded by

Jaswanth Kumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
21 views11 pages

Oop L23

The document discusses exception handling in Java using try, catch, throw, throws, and finally. It provides examples of how to throw exceptions explicitly using throw, how to declare exceptions that a method may throw using throws, and how finally blocks are used to ensure code is executed even if an exception occurs or the method returns early.

Uploaded by

Jaswanth Kumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 11

OOP L23

throw
• Apart from catching exceptions that are thrown by the Java run-time
system, it is possible for your program to throw an exception
explicitly, using the throw statement.
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 in 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.
• The nearest enclosing try block is inspected to see if it has a catch
statement that matches the type of exception. If it does find a match,
control is transferred to that statement.
• If not, 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.
class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
throw e; // rethrow the exception
}
}
public static void main(String args[]) {
try {
demoproc();
} catch(NullPointerException e) {
System.out.println("Recaught: " + e);
}
}
}
Note:
• new is used to construct an instance of NullPointerException. Many of
Java’s builtin run-time exceptions have at least two constructors: one
with no parameter and one that takes a string parameter. When the
second form is used, the argument specifies a string that describes the
exception. This string is displayed when the object is used as an
argument to print( ) or println( ). It can also be obtained by a call to
getMessage( ), which is defined by Throwable.
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.
• This is done by including a throws clause in the method’s declaration.
• This is necessary for all exceptions, except those of type Error or RuntimeException,
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.
type method-name(parameter-list) throws exception-list
{
// body of method
}
• Example without throws

class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
throwOne();
}
}
Example with throws
class ThrowsDemo {
static void throwOne() throws IllegalAccessException {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
try {
throwOne();
} catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
Output:
} inside throwOne
} Caught java.lang.IllegalAccessException: demo
finally
• When exceptions are thrown, execution in a method takes a rather
abrupt, nonlinear path that alters the normal flow through the method.
• Depending upon how the method is coded, it is even possible for an
exception to cause the method to return prematurely. This could be a
problem in some methods.
• For example, if a method opens a file upon entry and closes it upon
exit, then you will not want the code that closes the file to be bypassed
by the exception-handling mechanism.
• The finally keyword is designed to address this contingency.
• 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.
• 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.
• This can be useful for closing file handles and freeing up any other resources.
• The finally clause is optional.
• However, each try statement requires at least one catch or a finally clause.
• Example:
class FinallyDemo {
static void procC() {
static void procA() { try {
try { System.out.println("inside procC");
} finally {
System.out.println("inside procA");
System.out.println("procC's finally");
throw new RuntimeException("demo"); }
} finally { }
public static void main(String args[]) {
System.out.println("procA's finally");
try {
} procA();
} } catch (Exception e) {
static void procB() {
System.out.println("Exception caught");
}
try { procB();
System.out.println("inside procB"); procC();
return; }
}
} finally {
System.out.println("procB's finally");
}}

You might also like