[Java] ActionListener.

[Bazenga]

Hey, assuming that we have a class called GUI, inside it, there is a button called B1. What does it mean when you write the following: B1.addActionListener (new ActionListener() { ...... }); ... what does that mean? I know that addActionListener() takes an object as an argument, and the class should implement ActionListener, which means that if GUI is implementing ActionListener, then the method would be: B1.addActionListener(this); ...

However, I'm not being able to understand the "new ActionListener", is it an object? If yes, how are we able to create an object from an interface?

[JamesCherrill]

  Phr34Ck said:

Hey, assuming that we have a class called GUI, inside it, there is a button called B1. What does it mean when you write the following: B1.addActionListener (new ActionListener() { ...... }); ... what does that mean? I know that addActionListener() takes an object as an argument, and the class should implement ActionListener, which means that if GUI is implementing ActionListener, then the method would be: B1.addActionListener(this); ...

However, I'm not being able to understand the "new ActionListener", is it an object? If yes, how are we able to create an object from an interface?

It's an example of something called an "anonymous inner class" (which you can look up for full details).

Briefly:

new Thing(){//methods etc here}

creates a new instance of a new un-named class that extends/implements Thing

So what you're doing is creating a a new instance of an anonymous class that implements ActionListener.

The definition of the class (especially the actionPerformed method required by ActionListener) follows in the { ..... }.

This is the preferred way to create ActionListeners. If you use your GUI class as the ActionListener then you can have only one actionPerformed method - in which case its messy with mutliple buttons etc.

James

[Bazenga]

I was thinking about it, and it's the same thing with Exception handling. You throw a new Exception the way you want it, and then you handle it later, like when we use: throw new Exception() ... are they the same logic ?

[JamesCherrill]

  Phr34Ck said:

I was thinking about it, and it's the same thing with Exception handling. You throw a new Exception the way you want it, and then you handle it later, like when we use: throw new Exception() ... are they the same logic ?

Not really. new Exception() just creates a new instance of Exception.

With an anonymous inner class you are simultaneously defining and instantiating a brand new class.

add(new Thing() { .... methods etc});

is like a shorthand for

class MyThing extends Thing { .... methods etc}

add(new MyThing());

[Unholy Moley!]

It is important for you to know why you are creating an inner class. Inner classes are often used to create event handlers because the scope of the listener should be limited.

When you create a button, it's just a button. You can click on it, but if there is nothing "listening" to the click, nothing will happen to the button. You need to create an event handler to listen for that button click and then do something. First you must define an event listener class:

//inner class, you put this in another class to limit its scope.
class doStuff implements ActionListener{

public void actionPerformed(ActionEvent event){
 //You have to include this method, as defined by the ActionListener interface.
//Here, the stuff you want done when the event is "fired" goes here.
}
}

Next you must register the actionlistener to the respective component, be it a button, field, etc.

myComponent.addActionListener(new doStuff());

If you want to create the ActionListener object, then register it to the component, that is fine.

ActionListener handler = new doStuff();
myComponent.addActionListener(handler);

[Bazenga]

I do appreciate your reply Unholy Moley!, but that does not help me. I already know that, my question was about the myComponent.addActionListener (new ActionListerner() { .... }); that bit only. I'm not understanding what does that mean. What's happening there? I normally use the way you described, but I want to understand this way as well.

[Unholy Moley!]

  Phr34Ck said:

my question was about the myComponent.addActionListener (new ActionListerner() { .... }); that bit only. I'm not understanding what does that mean. What's happening there?

Oh, I understand your question now. To be honest, I've never seen that before either. It doesn't make much sense to me. Do you have a sample java file containing that code that can be compiled?

[Bazenga]

Here's a quick example

public class GUI extends JFrame
{
	private JButton B1;

	public GUI ()
	{
		 B1 = new JButton ("blabla");
		 B1.addActionListener ( new ActionListener() {
										  public void actionPerformed (ActionEvent e)
										  { //stuff here } }
										);
	 }
}

[JamesCherrill]

  Phr34Ck said:

Here's a quick example

public class GUI extends JFrame
{
	private JButton B1;

	public GUI ()
	{
		 B1 = new JButton ("blabla");
		 B1.addActionListener ( new ActionListener() {
										  public void actionPerformed (ActionEvent e)
										  { //stuff here } }
										);
	 }
}

Feels like I'm talking to myself here.

It's an anonymous inner class.

It's an anonymous inner class - remember Google anyone?

It defines a new class that implements ActionListener and, at the same time, creates a new instance of that class. The new instance is then added as the ActionListener for B1. All in one go.

It's the same as Unholy Moley's example, except that the class is defined in the same statement as where the instance is created and passed to addActionListener, so it doesn't need to have a name.

This web site explains it in rather cutesy language, if the official language definition is too heavy going. http://www.javaranch.com/campfire/StoryInner.jsp

James

[Bazenga]

Ahhh, your second post was everything I need. I makes sense now, so it created an innerclass directly that implements ActionListener, sweet.

Is it a good thing? If we had like 10 buttons in our class, and we used this method, we would be end up having 10 inner classes, yes? is it better then having only actionPerformed () in the class to handle the buttons?

[Unholy Moley!]

Thanks James.

[JamesCherrill]

  Phr34Ck said:

Ahhh, your second post was everything I need. I makes sense now, so it created an innerclass directly that implements ActionListener, sweet.

Is it a good thing? If we had like 10 buttons in our class, and we used this method, we would be end up having 10 inner classes, yes? is it better then having only actionPerformed () in the class to handle the buttons?

Good question! If you have just one actionPerformed() it's going to need to test which Button generated the Event in some horrid n-way if test (or a cunningly-created switch). I guess most people would rather have a separate method for each button, defined right there where it's added to the Button, rather than have all the code for all the buttons all mixed up in one big method. That's certainly the official Sun Java position. Think about what happens when you wan to add or remove Buttons, or, best of all, re-use a Button somewhere else! The whole reason for the anonymous inner class construct is that it allowes you to have the 10 classes with a minimum of code overhead.

10 classes or one big method - the choice is yours!

J