Possible Duplicate:
Anonymous code blocks in Java
I learned the other day (on SO) that
public method() {
someCode()
{
Object value = localCode();
doSomethingWith(value);
}
moreCode();
}
Is valid Java and it makes the block containing value local to that region, so value only exists in that block.
Is there any practical use for this? If not, why doesn't Java give a warning for this (silly) use of {}?
I use this in tests where I want to repeat different scenarios.
{
long start = System.nanoTime();
// do something
long time = System.nanoTime() - start;
// print result.
}
{
long start = System.nanoTime();
// do something else
long time = System.nanoTime() - start;
// print result.
}
{
long start = System.nanoTime();
// do something else again.
long time = System.nanoTime() - start;
// print result.
}
This allows be to copy the code without having to change the names, or risk re-using variables.
Not sure that this is actually why, but suppose the following (somewhat contrived) senario:
public static void main(String[] args){
int[] idsToCheck = {};
{
ExpensiveIDComputer sic = new ExpensiveIDComputer(); // very memory intensive call
idsToCheck = sic.getIds();
}
// sic is now out of scope and can be GCed faster
doManyOperationsOnIds(idsToCheck);
}
So essentially, it would allow you to enable memory-hogging operations to be garbage collected faster. Why you wouldn't just use another method, I don't know, but this was my first thought upon reading your question.
... so moreCode only has the value of value in that block.
That's not exactly correct, if moreCode is not declared inside the block. For example:
int moreCode = 0;
{
moreCode = 1;
System.out.println(moreCode);
}
// Will print 1, not 0!
System.out.println(moreCode);
You can use this to limit the scope of variables. If you declare a variable inside the block, it will only exist inside the block.
{
int moreCode = 1;
System.out.println(moreCode);
}
// Compile error: The variable moreCode doesn't exist here
System.out.println(moreCode);
This is, however, not something that is commonly used. If you feel that you need to use blocks for limiting scope in this way, then your methods are probably too complicated and you should consider splitting them up into simpler methods.
I use this for three reasons:
Most frequently, to declare/use temporary values, while I'm initializing one or more final values:
final int value;
{
final int counter;
... compute value ...
value = counter;
}
To otherwise "do work" without introducing variables into the outer namespace (limit scope).
To highlight/distinguish a section of code that belongs together, but I'm not yet ready to promote to an independent method (generally to maintain locality of the code for readability of the whole). [In 90% of any use-case, the code should be promoted - this somewhat exceptional].
No, if moreCode variable was declared outside the { } block, it will retain value unless its changed during execution.
Initialization blocks don't get used that often.
But its great to have when your class has multiple constructors, which should do some common initialization operations like initializing some variables or load some data.
You can paste the common constructor code into the initialization block like shown below. There is also the fact that initialization block will only be executed after the constructor and parent constructor.
Initializer blocks for instance variables look just like static initializer blocks, but without the static keyword:
{
// whatever code is needed for initialization goes here}
The Java compiler copies initializer blocks into every constructor. Therefore, this approach can be used to share a block of code between multiple constructors.
Reference: http://docs.oracle.com/javase/tutorial/java/javaOO/initial.html
Example would be instance initializers where code must catch exceptions.
class SomeClass {
private int myVar;
// Instance initializer
{
try{
myVar = getInitialValueFromDB();
}
catch(Exception e){
myVar = -1;
}
}
// no constructor here
// ...
}
If you named your codeblock you can break the block by adressing the name.
name1 : {
name2 :{
final int i = 1;
if( i == 1) {
break name1;
}
System.out.println("name2");
}
System.out.println("name1");
}
You are also able to limit the scope of a variable, so after the end of the block the variable can easily gargabe-collected.
It also lets you add labels so you can make spaghetti code!
MY_LABEL: {
if (condition) {
break MY_LABEL;
}
System.out.println("IN BLOCK");
}
System.out.println("OUTSIDE BLOCK");
If condition is true then the control flow will skip right over the first print statement and you'll only get the second print.
Disclaimer: I don't recommend using spaghetti code—this is only a hypothetical discussion of what you could do with a block like that.
another use case: declaring final variables for anonymous subclasses. Obviously, you can't just reference "foo" in the anonymous subclass below. You'd have to make it "final". As an alternate, we copy the value into a new final variable and use that. The new variable is a snapshot value of "foo" as of the that particular point of time during the execution.
int foo = 1;
....
{
final int bar = foo;
Future<Void> future = executorService.submit(new Callable<Void>() { // use bar here });
}
I realize you could do this without the braces, but this limits the scope of the new variable.
