Living with Exceptions

In Java, exceptions occur when some non-planned issue occurs that interrupts the normal flow of execution. Exception handling is accomplished in one of two general ways. The first is to simply allow the exception to propagate up the call stack. This is accomplished by adding the throws keyword and a list of exception types to the method declaration. The second approach is to execute code that may throw an exception inside of a try block. Immediately following the try block will be one or more catch blocks that catch the different exception types that may occur in the preceding try block. The catch block(s) may be followed by a finally block that is used for cleanup.

In the code sample below, an exception is raised at line 3 triggering a change in the expected flow of control in the program. Since the exception in some_method() was not in a try block, control transfers back to a_method(), which was invoked at line 8. In a normal (non-exceptional) situation the program would advance to line 9. Since the exception is in a try block, execution will transfer to the associated catch block to handle the exception. In the catch block the exception may be handled, ignored, or re-thrown. Note that at line 12 there is a return statement. If this code was not being executed as part of exception handling, control would return to the main() method. However, since this code is part of exception handling and there is a finally block, the code at line 15 will be executed before the return takes effect. If line 12 was a System.exit() invocation, the finally block would still be executed prior to the exit occurring.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 public class ExceptionHandling {
     public static void some_method() throws Exception {
         throw new Exception("Manually Thrown Exception");
     }
     public static void a_method(){
         try {
             System.out.println("Before Exception");
             some_method();
             System.out.println("After Exception");
         } catch (Exception e) {
             System.out.println("Handling Exception");
            return;
         }
         finally{
             System.out.println("Entered Finally");
         }
     }
     public static void main(String[] args){
         System.out.println("Calling Method");
         a_method();
         System.out.println("Returned From Method");
     }
 }

Note in the output below that After Exception is never printed. Once an exception has occurred, the execution in the try block is done.

Calling Method
Before Exception
Handling Exception "Manually Thrown Exception"
Entered Finally
Returned From Method

A common pattern of execution is to handle the exception, and then continue execution after the try-catch-finally construct as shown below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 public class ExceptionHandlingRecover {
     public static void some_method() throws Exception {
         throw new Exception("Manually Thrown Exception");
     }
     public static void a_method(){
         try {
             System.out.println("Before Exception");
             some_method();
             System.out.println("After Exception");
         } catch (Exception e) {
             System.out.println("Handling Exception");
         }
         finally{
             System.out.println("Entered Finally");
         }
         System.out.println("Continuing After try-catch-finally");
     }
     public static void main(String[] args){
         System.out.println("Calling Method");
         a_method();
         System.out.println("Returned From Method");
     }
 }

Calling Method
Before Exception
Handling Exception
Entered Finally
Continuing After try-catch-finally
Returned From Method

This is potentially dangerous since the execution context may not be what you expect, especially if more than one exception is possible in try block.

1
2
3
4
5

try {
    some_exception_causing_method();
} catch (Exception e) {
    e.printStackTrace();
}