What do curly braces by themselves mean in java?

Question

for example, I have the following code (generated, not written)

  if(node.getId() != null)
    {
        node.getId().apply(this);
    }
    {
        List<PExp> copy = new ArrayList<PExp>(node.getArgs());
        for(PExp e : copy)
        {
            e.apply(this);
        }
    }
    outAMethodExp(node);

What do those extra curly braces mean?

Answer 1

They make an inner scope. Variable declared inside these braces is not visible outside of them. This also applies to C/C++.

Answer 2

i think they just define an unnamed level of scope

Answer 3

They define a new scope which means that everything declared in this scope is not visible outside the curly braces.

Answer 4

The only purpose of the extra braces is to provide scope-limit. The List<PExp> copy will only exist within those braces, and will have no scope outside of them.

If this is generated code, I assume the code-generator does this so it can insert some code (such as this) without having to worry about how many times it has inserted a List<PExp> copy and without having to worry about possibly renaming the variables if this snippet is inserted into the same method more than once.

Answer 5

I'd actually guess that someone forgot an else statement...

EDIT:

Jesus Christ you people can be dense. There's rarely a good reason to even bother with creating additional block scopes. In this, and most cases, it's far more likely someone may have forgotten to type their control statement than it is that they were doing something clever.

Answer 6

The bring a scope, copy will not be visible outside of it, so you can declare another variable with same name later. And can be gathered by garbage collector right after you exit that scope. In this case copy serves as a temporary variable, so it is a good example.

Answer 7

As an interesting note: the braces actually enable a class of statements: declarations.

This is illegal: if(a) int f;

but this is legal: if(a) { int f; }

Answer 8

I second what matt b wrote, and I'll add that another use I've seen of anonymous braces is to declare an implicit constructor in anonymous classes. For example:

  List<String> names = new ArrayList<String>() {
    // I want to initialize this ArrayList instace in-line,
    // but I can't define a constructor for an anonymous class:
      {
        add("Adam");
        add("Eve");
      }

  };

Some unit-testing frameworks have taken this syntax to another level, which does allow some slick things which look totally uncompilable to work. Since they look unfamiliar, I am not such a big fan myself, but it is worthwhile to at least recognize what is going on if you run across this use.

Answer 9

I agree with the scope limit answer, but would add one thing.

Sometimes you see a construct like that in the code of people who like to fold sections of their code and have editors that will fold braces automatically. They use it to fold up their code in logical sections that don't fall into a function, class, loop, etc. that would usually be folded up.