How can I use listeners to access other elements?

Question

I'm setting up a GUI where I need to take information inputted from form elements and manipulate the information. This requires me to use some elements to access others.

For example, I have an input box (JTextField) and a button (JButton) beside it. When the button is pressed, I need to be able to manipulate the text entered into the input box. Everything I've tried to do so far to get this done has failed.

This is what my code looks like right now (I've embedded my questions in the comments):

public class MyClass
{
    public static void main(String args[])
    {
     // Form elements are in here
     JTextField myTextField = new JTextField(10);
     JButton myTextFieldSubmit = new JButton("Submit");
     myTextFieldSubmit.addActionListener(new ListenerClass());
    }
}

class ListenerClass implements ActionListener
{
    public void actionPerformed(ActionEvent e)
    {
     // This is what happens when these elements are used
     // I need to be able to access the form elements from MyClass in here, but this doesn't seem possible with my current setup
     // For example, when the Submit button is pressed, I need to be able to myTextField.getText() and edit MyClass members
     // How should my setup be changed to accommodate these needs?
    }
}

Thanks for any help!

Answer 1

You can pass in a reference to MyClass in the constructor to ListenerClass.

Answer 2

Your problem is common to the use of listeners for any purpose in Java: How to let the handler access the object that notified the listeners or his peers.

There are generally two conventions.

One is to get the object directly from the event object. You could do this with getSource(). But then you would only get the widget that did it.

Another option is to have the listener class be able to access the widgets. One way is to use a non-static internal classes (it is depends on how you declare it), in which case it is allowed to access the members of the containing class.

However, in this case your widgets are variables, not members (are you sure you want to do that?). So your only solution would be to have members holding them in the Listner class, and then instead of creating the listener in the addListener call, create a listener, pass the relevant widgets, and add the listener. The listener can now access those widgets through his own references to them which are stored in the members.

Answer 3

This is very much a variable scope issue.

Currently, the text field and button are in the scope of the main method, so having a separate class for the ActionListener will mean that it will not have access to those variables.

There are a few ways to achieve this:

(1) Make an inner class ListenerClass in MyClass, and turn the myTextField and myTextFieldSubmit into instance fields of MyClass.

public class MyClass
{
  final static JTextField myTextField = new JTextField(10);
  final static JButton myTextFieldSubmit = new JButton("Submit");

  public static void main(String args[])
  {
    myTextFieldSubmit.addActionListener(new ListenerClass());
  }

  static class ListenerClass implements ActionListener
  {
    public void actionPerformed(ActionEvent e)
    {
      myTextField.setText("");
    }
  }
}

(2) Make an anonymous inner class in the main method, and this will allow myTextField and myTextFieldSubmit to remain in the same place, as long as they are declared final.

public class MyClass
{
  public static void main(String args[])
  {
    final JTextField myTextField = new JTextField(10);
    final JButton myTextFieldSubmit = new JButton("Submit");

    myTextFieldSubmit.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e)
        {
         myTextField.setText("");
        }
    });
  }
}

(3) Make a local class that is local to the main method. Again, this will require the text field and button to be declared final to allow access from the inner class.

public class MyClass
{
  public static void main(String args[])
  {
    final JTextField myTextField = new JTextField(10);
    final JButton myTextFieldSubmit = new JButton("Submit");

    class ListenerClass implements ActionListener
    {
      public void actionPerformed(ActionEvent e)
      {
        myTextField.setText("");
      }
    }

    myTextFieldSubmit.addActionListener(new ListenerClass());
  }
}

(4) Handing an reference to the ListenerClass, for example in the constructor, and also making myTextField and myTextFieldSubmit an instance variable.

public class MyClass
{
  JTextField myTextField = new JTextField(10);
  JButton myTextFieldSubmit = new JButton("Submit");

  public MyClass()
  {
    myTextFieldSubmit.addActionListener(new ListenerClass(this));
  }

  public static void main(String args[])
  {
    new MyClass();
  }
}

class ListenerClass implements ActionListener
{
  MyClass myClass;

  public ListenerClass(MyClass myClass)
  {
    this.myClass = myClass;
  }

  public void actionPerformed(ActionEvent e)
  {
    myClass.myTextField.setText("");
  }
}

(5) Make myTextField and myTextFieldSubmit into static fields, and allow direct access from the ListerClass.

public class MyClass
{
  static JTextField myTextField = new JTextField(10);
  static JButton myTextFieldSubmit = new JButton("Submit");

  public static void main(String args[])
  {
    myTextFieldSubmit.addActionListener(new ListenerClass());
  }
}

class ListenerClass implements ActionListener
{
  public void actionPerformed(ActionEvent e)
  {
    MyClass.myTextField.setText("");
  }
}

There still probably are more ways to achieve this, and there may be better ways to implement this. The choice of which approach you take really depends up on the desired design of the application.