Exception-Handling Fundamentals

                   Exception-Handling Fundamentals

                       Java exception handling is managed via five keywords: try, catch, throw, throws, and finally. Briefly, here is how they work. 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 after a try block completes is put in a finally block.

Using try and catch :

                       The default exception handler provided by the Java run-time system is useful for debugging, you will usually want to handle an exception yourself. Doing so provides two benefits. First, it allows you 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 you want to monitor inside a try block. Immediately following the try block, include a catch clause that specifies the exception type that you wish to catch. To illustrate how easily this can be done, the following program includes a try block and a catch clause that processes the ArithmeticException generated by the division-by-zero error:

class Exc2 { public static void main(String args[])

 { int d, a; 

try {

 d = 0; a = 42 / d; 

System.out.println("This will not be printed."); 

} 

catch (ArithmeticException e) 

{ 

 System.out.println("Division by zero."); 

}

 System.out.println("After catch statement."); 

} }

This program generates the following output: 

Division by zero.

 After catch statement :

                         Notice that the call to println( ) inside the try block is never executed. Once an exception is thrown, program control transfers out of the try block into the catch block. Put differently, catch is not “called,” so execution never “returns” to the try block from a catch. Thus, the line “This will not be printed.” is not displayed. Once the catch statement has executed, program control continues with the next line in the program following the entire try/catch mechanism.

Throw :

                         Here it  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. 

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;

}

 }

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. 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. 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.

// 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();

 }

 }

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.

Here is an example program that shows three methods that exit in various ways, none without executing their finally clauses: 

// 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"); 

} 

}