Page History

If a finally clause is specified, irrespective Never use return, break, continue, or throw statements within a finally block. When program execution enters a try block that has a finally block, the finally block always executes regardless of whether the try block (or any associated catch block blocks) executes to completion or not, the finally block is executed.

Non-Compliant Code Example

normal completion. Statements that cause the finally block to complete abruptly also cause the try block to complete abruptly and consequently suppress any exception thrown from the try or catch blocks. According to The Java Language Specification, §14.20.2, "Execution of try-finally and try-catch-finally" [JLS 2015]:

If execution of the try block completes abruptly for any other reason R, then the finally block is executed. Then there is a choice:

• If the finally block completes normally, then the try statement completes abruptly for reason R.
• If the finally block completes abruptly for reason S, then the try statement completes abruptly for reason S (and reason R is discarded).

Noncompliant Code Example

In this noncompliant code example, the finally block completes abruptly because of a return statement in the block:Here, the finally block completes abruptly since a return statement occurs within it. As a result, when the exception is thrown in method someException, it does not show up in the output. This is due to the abrupt termination of the finally block that suppresses any useful exception information displayed in the try block by overriding it with its own message. Note that even if the try block returns some value, the finally block is executed.

class someExceptionTryFinally extends{
 Exception {private 
static boolean public someException(String sdoLogic() { 
    super(s);try {
  }
}

class TryFinally {
  private staticthrow voidnew throwExceptionIllegalStateException();
    throws} someExceptionfinally {
    throw new NullPointerException(System.out.println("logic done");
   }
   return true;
    }
  }
}

The IllegalStateException is suppressed by the abrupt completion of the finally block caused by the return statement.

Compliant Solution

This compliant solution removes the return statement from the finally block:

class TryFinally {
  private static private boolean doLogic() {
    try {
      throw new   throwExceptionIllegalStateException();
    } catch (someException se) { System.out.println("Exception thrown"); }
  
    finally {
              System.out.println("Uncaughtlogic Exceptiondone");
    }
    // Any return statements must go return true;
    }here; 
  }

  public// staticapplicable void main(String[] args) {
    doLogic();	only when exception is thrown conditionally
  }
}

Compliant Solution

Exceptions

ERRO4-J-EX0: Control flow statements whose destination is within This compliant solution removes the return statement from the finally block are perfectly acceptable. Likewise, keywords like break,continue and throw should never be used within a finally block.For example, the following code does not violate this rule because the break statement exits within the while loop but not within the finally block:

class someException extends Exception { class TryFinally {
  private static boolean doLogic() {
  public someException(String s)try {
    
  throw new superIllegalStateException(s);
  
  }
}

class TryFinally {
  private static void throwException() throws someException {
 finally {
      int c;
      try {
        while ((c = input.read()) != -1) {
         throw newif NullPointerException(c > 128);
  }{
            break;
  static private void doLogic() {
    try {}
        }
  throwException();
    } catch (someExceptionIOException sex) { System.out.println("Exception thrown"); }
  
    finally {
        // Forward to handler
        }
      System.out.println("Uncaughtlogic Exceptiondone");
    }
    // Any }

return statements publicmust staticgo void main(String[] args) {
    doLogic();	here; applicable only when exception is thrown conditionally
  }
}

References

Risk Assessment

Abrupt completion of a finally block masks any exceptions thrown inside the associated try and catch blocks.

Automated Detection

Related Guidelines

Bibliography

...

...

Image Added Image Added Image Added
Java Puzzlers 5.36