Cannot close() stream in 'finally' clause, uninitialized variable/unhandled IOException [Java IO]

Question

So I have this method in a class file just trying to write a Book object to aPath (string). However, it gives me 'Unhandled IOException', which I am not sure I understand why as it seems I have a catch clause for my try block.

So to fix this, I tried adding a 'throws' clause to my method, however once I did that, it said that the 'out' variable was not initialized.

Is there any way I can close my stream inside the finally clause?

    public void writeToFile(String aPath) {
    
        ObjectOutputStream out;
        try {
            out = new ObjectOutputStream(new FileOutputStream(aPath));
            
            out.writeObject(this.book);
        }
        catch(IOException e){
            System.out.println("Error writing to file");
            e.printStackTrace();
        }
        finally {
            out.close(); //unhandled IOException error :(
        }
    }

Answer 1

Using try with resources will handle the problem of uninitialized resources:

public void writeToFile(String aPath) {
    try (ObjectOutputStream out = 
             new ObjectOutputStream(new FileOutputStream(aPath))) {
        out.writeObject(this.book);
    }
    catch (IOException e) {
        System.out.println("Error writing to file");
        e.printStackTrace();
    }
}

According to the JLS, an IOException thrown by the writeObject call, OR by the implicit close() of the resource will be caught in that handler.

It is so elegant...

---

Regarding, your attempt:

I want to know why I cannot use out.close() in finally clause.

Because out has not necessarily been initialized. For example, if the IOException was thrown in new FileOutputStream(...) , out won't have been initialized. To get it to work using an explicit finally , you would need to do something like this:

public void writeToFile(String aPath) {
    ObjectOutputStream out = null;
    try {
        out = new ObjectOutputStream(new FileOutputStream(aPath));
        out.writeObject(this.book);
    }
    catch (IOException e) {
        System.out.println("Error opening or writing to file");
        e.printStackTrace();
    }
    finally {
        if (out != null) {
            try {
                out.close();
            }
            catch (IOException e) {
                System.out.println("Error closing file");
                e.printStackTrace();
            }
        }
    }
}

Since you asked.... the exception handling / squashing is probably a bad idea:

• The caller gets no indication file write has failed. It will continue executing as if nothing happened.

• A stacktrace should not normally be written to stdout. If it is relevant, the stacktrace should be logged:

  • If this is an end-user application, showing stacktraces to users is nasty. What they need is an informative error message. Separately logging the exception / stacktrace to a log file may be useful for the sysadmin who installed / configured the software, or the programmer who wrote it.
  • If this is a service, then stuff written to standard output may be lost. Real errors should be logged. Things that are (maybe) due to bad user input should (maybe) not be logged.