Understanding event listeners in java

Question

I'm new to java and I'm still trying to understand the language, so I apologize if this question might sound noobish.

There's something I don't understand about listeners, sometime you can see a listener declared in such a fashion:

    private View.OnClickListener onSave=new View.OnClickListener() {
public void onClick(View v) {

// Some code

}

};

or:

javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });

The thing that perplex me the most is that semicolon and parenthesis after the end of the method.

I understand inner classes for the purpose of having multiple listeners, but I don't understand this mixed declaration of variables and method.

Which purpose it has?

How is it declared?

WTF? :P

cheers :)

Similar to [How are Anonymous (inner) classes used in Java? ](http://stackoverflow.com/questions/355167/how-are-anonymous-inner-classes-used-in-java). — Matthew Flaschen, Jan 22 '11 at 16:54

Bert F · Accepted Answer · 2011-01-22T23:59:38.960

Normally defining a class, instantiating an instance, and then using that instance are done separately:

class MyListener extends OnClickListener {
    public void onClick(View v) {
        // my onClick code goes here
    }
}

MyListener foo = new MyListener();

button.setOnClickListener(foo);

But sometimes you need a subclass that you will instantiate only once immediately, which is often the case for event handlers. It is convenient to define it and instantiate it together using an anonymous (inner) class:

OnClickListener foo =
    new OnClickListener() {
        public void onClick(View v) {
            // my onClick code goes here
        }
    };

button.setOnClickListener(foo);

But since foo is only used once, we can takes this one step further and eliminate the local variable foo as well, so:

button.setOnClickListener(foo);

can be formatted as:

button.setOnClickListener(
    foo
);

substitute in the value of foo:

button.setOnClickListener(
    new OnClickListener() {
        public void onClick(View v) {
            // my onClick code goes here
        }
    }
);

reformatted again without some much whitespace to see it as it is often written:

button.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
        // my onClick code goes here
    }
});

I think this last format hurts readability. I format my anonymous classes similar to how it is in the next to last format - the better readability (IMHO) is worth a little extra whitespace.

duffymo · Answer 2 · 2011-01-22T16:58:40.647

2

Break it down...

javax.swing.SwingUtilities.invokeLater(Runnable runnable);

invokeLater() is a static method on SwingUtilities that takes a Runnable as a parameter.

Note the right parenthesis and semi-colon at the end; it's just a standard method, right?

The stuff in the middle is just creating a new instance of a Runnable to pass to the method. You're recognize it better if I assigned it to a reference:

Runnable parameter = new Runnable() 
{
    public void run() 
    {
        createAndShowGUI();
        }
    }
};

edited Jan 22 '11 at 16:58

answered Jan 22 '11 at 16:53

duffymo

305,152
44
369
561

You forgot a semicolon at the end of the inner class, but otherwise good answer! – Christian Mann Jan 22 '11 at 16:54

score 2 · Answer 3 · answered Jan 22 '11 at 16:57

There's nothing perplexing about the semicolon or parentheses here. Basically, this is one way to assign an anonymous class in Java. If you are not used to this construct, you can certainly create your own class that implements Runnable, and assign it like this:-

public class YourRunnableClass implements Runnable {
   public void run() {
      ...
   }
}

Then you can make it look nicer, like this:-

javax.swing.SwingUtilities.invokeLater(new YourRunnableClass());

P/S: Try not to use "WTF" in your post. :)

If you want to see a more detailed description of anonymous inner classes, look here: http://radio.javaranch.com/corey/2004/05/05/1083766724000.html — McGlone, Jan 22 '11 at 17:03

score 1 · Answer 4 · answered Jan 22 '11 at 16:53

1

That is an anonymous inner class. It's a very common and handy construct. Read the tutorial I linked to!

answered Jan 22 '11 at 16:53

Dr G

3,987
2
19
25

PeterMmm · Answer 5 · 2011-01-22T16:59:55.793

1

That code applies anonymous classes. Search and read for this topic.

The semicolon terminates the assignment respectively the method invocation.

PS. I always was thinking the name is something misleading because what you really get is an Object.

edited Jan 22 '11 at 16:59

answered Jan 22 '11 at 16:54

PeterMmm

24,152
13
73
111

score 1 · Answer 6 · answered Jan 22 '11 at 16:57

I'll try to exemplify the second example.

In this case invokeLater method expects any object which implements the Runnable interface.

for example, this is an alternative way of writing the same thing without an anonymous class:

class Example implements Runnable{
  public void run(){
    // do something
  }
}

and your example could be:

javax.swing.SwingUtilities.invokeLater(new Example());

But since this Example class it's likely you'll use it only once, it's more convenient to use an anonymous class.

Understanding event listeners in java

6 Answers6