Java Exceptions – Handling Non-Initialized Objects in the Finally Block

exceptionsfinallyjava

I like using final variables whenever possible. Often those variables have to be closed afterwards. Note that I'm currently working on Java 6 so there is not closeable interface, but the same applies to later Java versions as well. For example:

final InputStream in;

try{
    in=new InputStream(...);
    //...
}catch(...) {}
finally{
    in.close(); //whoops!
}

At that point the IDE will point out that in might be uninitialized. Wrapping the close statement in an if like so

if(in!=null)
    in.close();

doesn't work either, despite null being the default value for uninitialized objects. My solution so far is to forget about declaring them final in the first place, and initializing them as null at declaration.

Another solution is to place the declaration and close statement in the try block:

try{
    final InputStream in=new InputStream(...);
    //...
    in.close();
}catch(InputStreamRelatedException) {};

which would leave in open (?) in case of non-InputStream related exception.

What is the preferred method?

Best Answer

You are running into difficulties because you are trying to handle two different cases with the same try-catch:

constructing the InputStream could fail, in which case you also can't close() anything.
using the InputStream could fail, in which case you need a close().

The solution is to separate these cases, and not instantiate the object in the same scope where it might be used:

final InputStream in;
try { in = new InputStream(); }
catch (...) { ... /* must throw or return, or assign to `in` */ }

try { doSomethingWith(in); }
catch (...) { ... }
finally { in.close(); }

Related Solutions

Java – How to remove duplicate exception block code

Extract the exception handling into a method:

public interface Action {
    public void execute() throws ...;
}

public static void handleErrors(Action action) throws ... {
   try {
      // setup .....
      action.execute();
   } catch (...) {
      // ...
   } finally {
      // cleanup ...
   }
}

Then call it like this:

handleErrors(new Action(){ public void execute() throws ... {
    // ...
}});

The syntax is ugly, but it's still much better than duplicating the error handling dozens of times. Anytime you are duplicating more than a couple of lines, you should stop and figure out how to avoid that duplication. In Java, this often means using interfaces and anonymous classes to pass one block of code to run inside some common control logic. The same technique can be reused to eliminate duplicated looping code.

Java – Difference Between Code in Finally Clause and After Catch Clause

The finally {} block is always called (unless you call exit() before finally is reached - but you won't be doing that most of the time).

The purpose of finally is to clean up any resources allocated in the try {} block, even if something was thrown and it hit the catch{} block.

Consider the code:

public class Hello {

    public static void main(String[] args) {
        hello();
    }

    public static void hello() {
        try {
            System.out.println("hi");
            return;
        } catch (RuntimeException e) {
        } finally {
            System.out.println("finally");
        }
    }
}

While there isn't any resource allocation in this, just pretend there is. This will print out:

hi
finally

If you had opened a file in the try block, the finally is the place to clean it up. If you had opened one file, and then tried to open another one (that threw an exception), the finally is the place to clean that up.

If there was an uncaught exception by the catch block, then the finally would run, and the exception would get passed on up.

Putting out.close() in the catch and the finally is redundant - because it will be run in the finally block - on a caught exception or successful completion of the try.

With the existing code, the following code paths are possible:

No exception:
1. check() - no exception thrown
2. finally { } - out.close
Caught exception:
1. check() - MissingParamException thrown
2. catch { } - stuff and out.close
3. finally { } - out.close
Uncaught exception:
1. check() - NPE thrown
2. finally { } - out.close

You should be able to see from this, the finally is always called, and in the caught exception, out.close() is invoked twice.

The associated spec is §14.20.2 in Java SE 7 language specification.

Best Answer

Related Solutions

Java – How to remove duplicate exception block code

Java – Difference Between Code in Finally Clause and After Catch Clause

Related Topic