Declaration of variables / references - What difference does it make?

[Srinath Kannan]

Hi,

Whenever i code in Java, i had this habit of declaring variables, stacking them on top of method! In my perception i did this thinking that it improves clarity, readability.. also it was like a code beautification!

I am aware of the following

1 . Usually one would declare the variables/references in the top of method to decide its scoping..meaning they would require the variable or reference in the catch or finally block

2 . Declaring variables/references in the top of method and initializing them with Null or some values! would lead to Null exceptions if not instantiated inside subsequent parts of code

When i googled on this, It was said in some forum "that declare variable close to where you need it!" because its easy for JVM while doing deallocation!

Please see the below sample code snippet and help me to understand which is the best option in terms of coding standard / de-allocation?

Option 1:

public void checkMessage(String inputFolder){
		try{
			File directory = new File(inputFolder);
			File files[] = directory.listFiles());
			for(int r=0;r<files.length;r++) {
			   boolean isSuccess = false;
			   StringBuffer mBuffer = new StringBuffer();
			   File afile = files[r];
			   String fileName = afile.getName();
			   String mId = fileName.substring(7,17);
			   String strLine = null;
			   BufferedReader bufferedFileReader = new BufferedReader(new FileReader(aFile));
			   while ((strLine = bufferedFileReader.readLine()) != null)   {
				   mBuffer.append(strLine + lineSeparator);    					 
				}
				bufferedFileReader.close();
				/**
				* with this mBuffer contents, some process is done here
				*/
			}
			} catch(Exception e) {
				e.printStackTrace();
			} finally {
				//close resources if any
			}
}

Option 2:

public void checkMessage(String inputFolder){
	File directory = null;
	File files[] = null;
	File afile = null;
	String fileName = null;
	String mId = null;
	String strLine = null;
	boolean isSuccess = false;
	StringBuffer mBuffer = null;
	BufferedReader bufferedFileReader = null;
		try{
			directory = new File(inputFolder);
			files[] = directory.listFiles());
			for(int r=0;r<files.length;r++) {
			   isSuccess = false;
			   mBuffer = new StringBuffer();
			   afile = files[r];
			   fileName = afile.getName();
			   mId = fileName.substring(7,17);
			 
			   bufferedFileReader = new BufferedReader(new FileReader(aFile));
			   while ((strLine = bufferedFileReader.readLine()) != null)   {
				   mBuffer.append(strLine + lineSeparator);    					 
				}
				bufferedDeadFileReader.close();
				/**
				* with this mBuffer contents, some process is done here
				*/
			}
			} catch(Exception e) {
				e.printStackTrace();
			} finally {
				//close resources if any
			}
}

Comparing option 1 and 2! what difference do you see in terms of coding standard / de-allocation?

[Matthew Brown]

Personally, I wouldn't be worrying much about the compiler or JVM. I'd use the first approach because I think it's far easier to read.

[Srinath Kannan]

Hi Matthew,

Thanks your comments!

All these days i was using option 2, from now i will use option 1. Other than readability, like in terms of memory allocation / performance do you see any difference? Is that going for option 1 guarantee's correct de-allocation at the right time!

[Jim Hoglund]

My preference is to minimize variable scope; declare them
at first use and then expand their scope only as necessary.
This provides minimum typing and maximum safety.

Jim ...

[Ralph Cook]

Srinath Kannan wrote:Hi Matthew,

Thanks your comments!

All these days i was using option 2, from now i will use option 1. Other than readability, like in terms of memory allocation / performance do you see any difference? Is that going for option 1 guarantee's correct de-allocation at the right time!

There is not enough difference in memory allocation / performance for you to alter your code at all. Readability, making it easier to change the code should it need it, etc., should be your primary considerations.

rc