Finally cause Exception be forgotten

Question

In trying out that finally cause previous return value be forgotten, as described on page 206 of "The Java Programming Language, 3rd edition", I wrote the following code, and tested it with jdk1.3.1. To my supprise, not only the return value was forgotten, the exception was appeared forgotten as well:
class PException extends Exception {
class Final {
    void f1(int i) {
     int result;
     System.out.println("f1("+i+")");
     try {
         result = f2(i);
         System.out.println("result = " + result);
     } catch(Exception e) {
         System.out.println("caught an Exception: " + e);
     try {
         result = f3(i);
         System.out.println("result = " + result);
     } catch(Exception e) {
         System.out.println("caught an Exception: " + e);
    int f2(int i) throws PException {
     try {
         if (i == 1) {
          System.out.println("generate exception");
          throw new PException();
         return 1;
     } finally {
         return 2;
    int f3(int i) throws PException {
     if (i == 1) {
         System.out.println("generate exception");
         throw new PException();
     return 1;
    public static void main(String[] args) {
     Final f = new Final();
     f.f1(1);
     f.f1(2);
     f.f1(1);
}Here is the result:
f1(1)
generate exception
result = 2
generate exception
caught an Exception: PException
f1(2)
result = 2
result = 1
f1(1)
generate exception
result = 2
generate exception
caught an Exception: PException

Answer 1

The concern here is that when the
try {
finally {
}pattern is used, without the catch block, purelly for flow control purpose, a return statement in the finally block could be problematic. If a finally block ends with a return statement, any exception that might be thrown in the try block would be ignored. The unhandled exception will not propergate, it simply lost in the midst. Because any code could throw unchecked exception, if the exception cannot afford to be lost, then one should be careful not to use return in the finally block. See the following test code:
class Finally {
    void test() {
     int result;
     System.out.println("test()");
     try {
         result = f1();
         System.out.println("result = " + result);
     } catch(Exception e) {
         System.out.println("Caught an Exception: " + e);
     try {
         result = f2();
         System.out.println("result = " + result);
     } catch(Exception e) {
         System.out.println("Caught an Exception: " + e);
     try {
         f3();
     } catch(Exception e) {
         System.out.println("Caught an Exception: " + e);
     try {
         f4();
     } catch(Exception e) {
         System.out.println("Caught an Exception: " + e);
    int f1() {
     System.out.println("f1()");
     int a = 0;
     int b = 0;
     try {
         a = 1/0;  // this generate an unchecked exception
         b = 1;
     } finally {
         return b; // this return clobber the unchecked exception
    int f2() {
     System.out.println("f2()");
     int a = 0;
     int b = 0;
     a = 1/0; // this generate an unchecked exception
     b = 1;
     return b;
    void f3() {
     System.out.println("f3()");
     int a = 0;
     int b = 0;
     try {
         a = 1/0;  // this generate an unchecked exception
         b = 1;
     } finally {
         return;   // this return clobber the unchecked exception
    void f4() {
     System.out.println("f4()");
     int a = 0;
     int b = 0;
     try {
         a = 1/0;  // this generate an unchecked exception
         b = 1;
     } finally {
    public static void main(String[] args) {
     Finally f = new Finally();
     f.test();
/code]
Here are the results:test()
f1()
result = 0
f2()
Caught an Exception: java.lang.ArithmeticException: / by zero
f3()
f4()
Caught an Exception: java.lang.ArithmeticException: / by zero
We see that the devide by zero exception throw by f1() simply vanished, the unintended result 0, instead of the intended result 1, is returned. The test() method did not detect any abnormality in f1(), which is scary. To drive the point home, we try f3() and f4(), which has void return type. A simple return statement in f3() causes exception be lost. The stack frame seems intact, for otherwise, the test() method would exit abruptly before f2() even get a chance to be called.