Strange line of code

[Swerrgy Smith]

public class Foo 
{
    Foo() 
    {
        System.out.print("foo");
    }
    
class Bar
{
    Bar() 
    {
        System.out.print("bar");
    }
    public void go() 
    {
        System.out.print("hi");
    }
} /* class Bar ends */

    public static void main (String [] args) 
    {
        Foo f = new Foo();
        f.makeBar();
    }
    void makeBar() 
    {
        (new Bar() {}).go();
    }
}/* class Foo ends */

Hi,

In the code above, what does this line do?

 (new Bar() {}).go();

I am confused about {}!!! Is it going to create an ANONYMOUS SUBCLASS of Bar and execute the method go() of this subclass?

Thank you very much.

[Matthew Brown]

Swerrgy Smith wrote:Is it going to create an ANONYMOUS SUBCLASS of Bar and execute the method go() of this subclass?

Yes, spot on.

Try modifying the go() method in Bar to print out getClass().getName(), and you'll see the name of the class that actually gets executed. It'll probably be something like "Foo$1", which is how anonymous classes get named.

[sahil kumar garg sangrur]

(new Bar() {}).go();
this line simply makes the anonymous class which extends the Bar class and the object this anonymous class call the method of our super class
so print foobarhi foo prints when we make the object of foo class and bar prints when we make the object of subclass or anonymous class of bar class and at last hi prints..

[Winston Gutkowski]

Matthew Brown wrote:Yes, spot on.

@Swerrgy: Yes. And well done for working it out.

However, this looks like SCJP code to me; and it's worth remembering that it is only really designed to test your knowledge of the compiler. Don't expect to ever see anything like it in real life. And if you do...RUN.

And there's LOTS of stuff in that exam that you should forget as soon as you've passed it.

Winston

[Matthew Brown]

Try this one. Can you explain how the following works?

List<String> list = new ArrayList<String>() {{ 
    add("one");
    add("two");
    add("three");
}};

Some people even consider this a legitimate technique. They're wrong .

[Darryl Burke]

It even has a name: double-brace initialization.

Why do you consider it wrong?

[Henry Wong]

Darryl Burke wrote:It even has a name: double-brace initialization.

Why do you consider it wrong?

Perhaps, one reason could be ... if programmers ran amok with this technique, every time a collection needed to be instantiated, there would be class files all over place.

Henry

[Winston Gutkowski]

Darryl Burke wrote:Why do you consider it wrong?

Because it's arcane; and, as every programmer knows: simplicity (not brevity) is the essence of lingerie.

It took me a minute or so to work that one out. Never seen it before. Nice one Matthew.

Winston

[Mike Simmons]

Winston Gutkowski wrote:Never seen it before.

What, didn't you read this thread before you replied to it?

It is arcane to most of us, but it doesn't need to be. It's easy enough to grok once you've been exposed to it, IMO.

For completeness I would note that these days, I would use Google Guava to do this more nicely:

List<String> list = ImmutableList.of(
    "one",  
    "two",  
    "three"  
);  

Or if you really do need it mutable:

List<String> list = Lists.newArrayList(
    "one",  
    "two",  
    "three"  
);  

I just wish Java had nice collection literals like other languages.

[Matthew Brown]

Darryl Burke wrote:It even has a name: double-brace initialization.

Why do you consider it wrong?

To be fair, "wrong" is an exaggeration. I'm not a big fan, though, for reasons others have given. And it does just seem a bit, well, hacky. I'd agree with Mike - I'd prefer a proper initialiser syntax supported by the language.

[Darryl Burke]

Matthew Brown wrote:I'd prefer a proper initialiser syntax supported by the language.

I agree. VFP (also VB and probably other languages) has the "WITH / ENDWITH" keywords which I used extensively. With proper indentation, nested WITH clauses are eminently readable and concise.

In Java, double-brace initialization is the nearest thing to that, but can only be applied at construction.