Double {{ }} syntax question in java [duplicate]

Answer 1

You seem to be asking (at least) two different things here. The double-bracket idiom is known and often used as a shorthand for creating anonymous inner classes, replacing the explicit constructor with an initializer block. Usually this makes the code more readable, so I would say it's OK.

OTOH since (nonstatic) initializer blocks are a relatively recent addition to the language, some developers may not be familiar with them though, which may create confusion. And of course, as with almost any techniques, when overused, it can create more problems than it solves.

Answer 2

What you've done is called: "initialization block".

From doc:

The Java compiler copies initializer blocks into every constructor. Therefore, this approach can be used to share a block of code between multiple constructors

Example:

class A { 
    private String field1;

    {
        field1 = "example field";
        field2 = getstaticResult();
    }

}

But in my opinion we shouldn't use this very often and especially in your case it's very unusual to use it.

Answer 3

Like most questions of this nature, I unfortunately must say "it depends". When you do it this way, you're actually creating a new anonymous class, so there is an ever-so-slight performance hit in terms of memory and CPU, but under most circumstances I would say that it is insignificant enough to ignore. If doing it this way makes your code more readable, and if it is the style the rest of your team is using, I would say to go with it.

Answer 4

Nothing actually wrong with Double Brace Initialization; I often use it for maps and lists.

It maybe depends on who your audience is -- do the other people on your team understand what you're doing here? Remember that someday, somebody is going to have to read this code.

Answer 5

Two problems

• Leaking References: Since these are anonymous inner classes they keep a reference to the surrounding object which will keep them from being collected. This could cause hard to find memory leaks.

• Anonymous Types: For anything that relies on the exact class this can cause problems. For example Serialisation and some implementations of equals may not work as expected.

If you know that the above wont be a problem there is nothing wrong with using this syntax.