Exception handling in java.pptx

• 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
• 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 may choose to handle the
exception itself, or pass it on. Either way,
at some point, the exception is caught and
processed

• Exceptions can be generated by the Java
run-time system, or they can be manually
generated by your code.
• Exceptions thrown by Java relate to
fundamental errors that violate the rules of
the Java language or the constraints of the
Java execution environment.

• 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 in some rational
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 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
}

class Exc0 {
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.
• This causes the execution of Exc0 to stop,
because once an exception has been
thrown, it must be caught by an exception
handler and dealt with immediately.

• In this 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.

• Here is the output generated when this
example is executed.
• java.lang.ArithmeticException: / by zero
• at Exc0.main(Exc0.java:4)

• The stack trace will always show the
sequence of method invocations that led
up to the error.
• For example, here is another version of
the preceding program that introduces the
same error but in a method separate from
main( ):

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

• The resulting stack trace from the default
exception handler shows how the entire
call stack is displayed:
• java.lang.ArithmeticException: / by zero
• at Exc1.subroutine(Exc1.java:4)
• at Exc1.main(Exc1.java:7)

• The goal of most well-constructed catch clauses should be to
resolve the exceptional condition and then continue on as if the error
had never happened.
• For example, in the next program each iteration of the for loop
obtains two random integers.
• Those two integers are divided by each other, and the result is used
to divide the value 12345.

• The final result is put into a. If either
division operation causes a divide-by-zero
error, it is caught, the value of a is set to
zero, and the program continues.

• 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.
• You cannot use try on a single statement.
• That is, they must be within a block.
• The goal of most well-constructed catch clauses
should be to resolve the exceptional condition
and then continue on as if the error had never
happened.

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

• In some cases, more than one exception
could be raised by a single piece of code.
To handle this type of situation, you can
specify two or more catch clauses, each
catching a different type of exception.
• After one catch statement executes, the
others are bypassed, and execution
continues after the try/catch block.

• When you use multiple catch statements,
it is important to remember that exception
subclasses must come before any of their
superclasses.
• This is because a catch statement that
uses a superclass will catch exceptions of
that type plus any of its subclasses.

• Thus, a subclass would never be reached
if it came after its superclass.
• Further, in Java, unreachable code is an
error.
• Since ArithmeticException is a subclass
of Exception, the first catch statement will
handle all Exception-based errors,
including ArithmeticException.

• To fix the problem, reverse the order of the
catch statements.

• The try statement can be nested. That is,
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.

• If no catch statement matches, then the
Java run-time system will handle the
exception.
• Nesting of try statements can occur in less
obvious ways when method calls are
involved. For example, you can enclose a
call to a method within a try block.

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

• So far, you have only been catching
exceptions that are thrown by the Java
run-time system. However, 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.
• Simple types, such as int or char, as well
as non-Throwable classes, such as
String and Object, cannot be used as
exceptions.

• The flow of execution stops immediately
after the throw statement; any subsequent
statements are not executed.

• 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.
• You do this by including a throws clause
in the method’s declaration. 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 program contains an error and will not compile.
class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
throwOne();
}
}

• When exceptions are thrown, execution in
a method takes a rather abrupt, nonlinear
path that alters the normal flow through
the method.
• 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.
• 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 that
might have been allocated at the
beginning of a method with the intent of
disposing of them before returning.

Exception handling in java.pptx

More Related Content

Similar to Exception handling in java.pptx (20)

Recently uploaded (20)

Exception handling in java.pptx