Is this the way to use finally and try with resources ?

[Ganish Patil]

I have written two programs.

// A program to demonstrate how to write text (String) inform of bytes into a file.
import java.io.*;
class logFile{

    // Instance variable's fields declaration
    FileOutputStream foutObj1;
    String Message, fileName;
    byte[] msgBytes; 
    logFile(String fname, String msg){

    // Instance variable's fields initialization
    Message = msg;
    // Converts string into byte array
    msgBytes = Message.getBytes();  
    fileName = fname;
  
    // FileOutputStream object initialized and File is created if not exists at specified location
    try{   
        foutObj1 = new FileOutputStream("C:/Program Files/tooc/selfjava/File/WritetoFile/"+fileName);
        System.out.println(" FileOutputStream object instantiated successfully!");
        }catch(FileNotFoundException e){
             System.out.println(e.getMessage());    
        }
    }

    /* logWrite method writes message into file.
        finally block makes sure FileOutputStream's object is closed.
    */
    private void logWrite()throws IOException {
        try{   
            foutObj1.write(msgBytes);
            System.out.println(Message + " is written to file " + fileName + " successfully! ");
        }catch(Exception e){
            System.out.println(e.getMessage());    
        }
        finally{
            foutObj1.close();
            System.out.println(" FileOutputStream object closed successfully!");
        }
    }

    public static void main(String args[]) throws IOException{

    // file name and message to be written in file passed as arguments to constructor
    logFile clsObj1 = new logFile("Log.txt", "First file program"); 
    clsObj1.logWrite();        

    } // Main Ends
} // Class Ends

[Ganish Patil]

Same program with try with resources.

// A program to demonstrate how to write text (String) inform of bytes into a file using try with resources.

import java.io.*;
class logFile{
    String Message, fileName;
    byte[] msgBytes; 

    // file name and message instance variables initialized in constructor
    logFile(String fname, String msg){
        Message = msg;
        msgBytes = Message.getBytes();  // Converts string into byte array
        fileName = fname;
    }

    /* logWrite method creates new file if not exists and writes message into file.
        Use of try with resouces reduces code of catch and finally block. 
    */
    private void logWriter()throws IOException {
        try( FileOutputStream foutObj1 = new FileOutputStream("C:/Program Files/tooc/selfjava/File/WritetoFile/"+fileName); ){   
            System.out.println(" FileOutputStream object instantiated successfully!");
            foutObj1.write(msgBytes);
            System.out.println(Message + " is written to file " + fileName + " successfully! ");
        }    
    }

    public static void main(String args[]) throws IOException{

     // file name and message to be written in file passed as arguments
    logFile clsObj1 = new logFile("Log.txt", "First file prorgam" ); 
    clsObj1.logWriter();        

    } // Main ends
} // Class ends

Just want to know did I make use of finally and try with resources correctly? or do I have to improve it if yes then how ?

as I know, a try can have only one finally block and is used to recover resources and close objects created to free memory. try with resources reduces code of catch and finally. we don't have to catch exceptions and recover resources using finally it is done by try with resources it self so reduces code writing and makes it simple. Hope I'm on correct path ?

[Abhay Agarwal]

Code is correct.

Small improvements are
class name should start with capital letter (Logfile)
instance variables should be defined with private access modifier
semicolon is not needed in try with resource block if only one resource is mentioned.

as I know, a try can have only one finally block and is used to recover resources and close objects created to free memory.

This is correct.

try with resources reduces code of catch and finally. we don't have to catch exceptions and recover resources using finally it is done by try with resources it self so reduces code writing and makes it simple.

This is not correct.
A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.
Because the FileOutputStream instance is declared in a try-with-resource statement, it will be closed regardless of whether the try statement completes normally or abruptly (as a result of the method FileOutputStream.write() throwing an IOException).
So we can say that - try with resources reduces code of finally (not catch).
If exceptions are thrown from both the try block and the try-with-resources statement, then the method logWriter() throws the exception thrown from the try block; the exception thrown from the try-with-resources block is suppressed.You can retrieve these suppressed exceptions by calling the Throwable.getSuppressed method from the exception thrown by the try block.

[Ganish Patil]

yes i know class name should start with capital letter but I forgot that and

instance variables should be defined with private access modifier semicolon is not needed in try with resource block if only one resource is mentioned.

I never paid attention to this though I read about it. Thank you for try with resources information. Need a lot of practice because I read that already in JLS and forget while coding.

[Campbell Ritchie]

The first version is incorrect because you are not closing the Stream (line 21). Line 29 does not appear to throw any checked Exceptions.

[Ganish Patil]

you meant this line ?

foutObj1 = new FileOutputStream("C:/Program Files/tooc/selfjava/File/WritetoFile/"+fileName);

Line 21 is in constructor where I instantiated an object of FileOutputStream to write bytes to file so why should I close stream before using it ?

Line 29

private void logWrite()throws IOException

I did throw IOException what else I need to throw

Checked
Exception
IOException : Did throw this one
FileNotFoundException : Did while creating an object of FileOutputStream
ParseException :
ClassNotFoundException :
CloneNotSupportedException
InstantiationException
InterruptedException
NoSuchMethodException
NoSuchFieldException

Which one do you think I should throw if possible can you please elaborate..

[Campbell Ritchie]

Yes, you instantiated an object in line 21; where do you close it?
Actually, I may be mistaken about IOExceptions; you may suffer an Exception from the finally. The finally should be inside a try.

Create your readers and writers for files as local variables. Don't make them fields.

[Tim Holloway]

You need to close the outputstream. If you do not, the buffers may not flush out and you can lose data. Plus, even if you don't, the close of the physical disk file (or whatever) would have to wait until the garbage collector got around to destroying the output stream object, which means that other apps might see incomplete data for an indefinite period of time.

This sort of cleanup has actually become more of a thing now that we have "try with resources", since the scope of the "tried" object is more precisely limited and therefore there's an obvious point after which resources can be freed and cleaner (as for example, closing the file). I ran into this in Spring Data Neo4j, where they've redefined some of their functions to allow for that instead of requiring explicit cleanup.

[Ganish Patil]

Yes, you instantiated an object in line 21; where do you close it?

In private method logWrite i closed that after use

finally{
            foutObj1.close();
            System.out.println(" FileOutputStream object closed successfully!");
        }

you may suffer an Exception from the finally. The finally should be inside a try.

Opps ! I didn't think of that, never knew finally could be inside try. This is what happens when you skip a part of topic. I skipped that while reading JLS.

Create your readers and writers for files as local variables. Don't make them fields.

ya I was also skeptical about that but had habit of making them fields in college, yes will get rid of this habit ASAP.

[Ganish Patil]

@Tim ya got it, thank you for such precious information. Before I was like, wants to write a program which writes text into the file? I was like oh its very easy! but now I'm getting, its not that easy, need to take care of performance as well as memory and neat code.

[Campbell Ritchie]

Ganish Patil wrote: . . .
In private method logWrite i closed that after use

finally{
            foutObj1.close();
            System.out.println(" FileOutputStream object closed successfully!");
        }

. . .

The private method may be called more than once. You are now trying to write to a closed Writer. That problem would not have occurred if you had that Writer as a local variable.

Since Java7 and try‑with‑resources, this sort of ugly code has no longer been necessary:-

try
{
   XYZWriter writer = new XYZWriter(...);
   try
   {
      while (...)
      {
         writer.write(...);
      }
   }
   finally
   {
      writer.close();
   }
}
catch (XYZException exc)
{
   something(exc);
}

[Campbell Ritchie]

If you are simply writing text to a file consider using a Formatter.

[Ganish Patil]

The private method may be called more than once.

really splendid. thank you Campbell. I wish would have had teacher like you in my 6 years of education.

[Campbell Ritchie]

You're welcome

[Stephan van Hulst]

Campbell Ritchie wrote:

try
{
   XYZWriter writer = new XYZWriter(...);
   try
   {
      while (...)
      {
         writer.write(...);
      }
   }
   finally
   {
      writer.close();
   }
}
catch (XYZException exc)
{
   something(exc);
}

Actually, for those working with older Java versions, the correct way of doing this is:

try
{
  XYZWriter writer = new XYZWriter(...);
  try
  {
    while (...)
    {
      writer.write(...);
    }
  }
  finally
  {
    try {
      writer.close();
    }
    catch (IOException exc)
    {
      somethingWithoutExceptions(exc);
    }
  }
}
catch (XYZException exc)
{
  something(exc);
}

You should never exit a finally clause abruptly (through an exception or a return statement)

[Campbell Ritchie]

Stephan van Hulst wrote: . . .
Actually, for those working with older Java versions, the correct way of doing this is:
. . .

Thank goodness for try‑with‑resources.

[Stephan van Hulst]

Yes!