Wie kann ich Hörer verwenden, um andere Elemente zugreifen?

Question

Ich gründe eine GUI, wo ich Informationen von Formularelementen und manipulieren die Informationen eingegeben nehmen müssen. Dies erfordert mich einige Elemente zu verwenden, um andere zugreifen zu können.

Zum Beispiel habe ich ein Eingabefeld (JTextField) und einen Knopf (JButton) daneben. Wenn die Taste gedrückt wird, muss ich der Lage sein, den Text zu manipulieren in das Eingabefeld eingegeben. Alles, was ich habe versucht, so weit, dies zu tun zu tun zu bekommen, ist fehlgeschlagen.

Dies ist, was mein Code sieht aus wie jetzt (ich habe in den Kommentaren meine Fragen eingebettet):

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?
    }
}

Vielen Dank für jede Hilfe!

Answer 1

Das ist sehr viel ein Variable Umfang Thema.

Derzeit sind das Textfeld und Schaltfläche im Rahmen des main Methode, so dass für die ActionListener eine eigene Klasse, die bedeutet, dass es keinen Zugriff auf diese Variablen haben.

Es gibt ein paar Möglichkeiten, dies zu erreichen:

(1) Stellen Sie eine innere Klasse ListenerClass in MyClass, und schalten Sie den myTextField und myTextFieldSubmit in Instanzfelder von 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) Stellen Sie eine anonyme innere Klasse in der main Methode, und dies ermöglicht es myTextField und myTextFieldSubmit an der gleichen Stelle zu bleiben, solange sie final deklariert ist.

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) Machen Sie eine lokale Klasse, die auf die main Methode lokal ist. Auch hier wird das Textfeld und Schaltfläche erfordert final deklariert wird Zugang von der inneren Klasse zu ermöglichen.

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) Übergabe einen Hinweis auf die ListenerClass, beispielsweise in den Konstruktor, sowie myTextField machen und myTextFieldSubmit eine Instanzvariable.

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) Stellen Sie myTextField und myTextFieldSubmit in static Felder und ermöglichen den direkten Zugriff von der 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("");
  }
}

Es gibt immer noch gibt wahrscheinlich mehr Möglichkeiten, dies zu erreichen, und es können bessere Möglichkeiten, dies zu implementieren. Die Wahl der Ansatz, den Sie wirklich nehmen auf das gewünschte Design der Anwendung hängt auf.

Answer 2

Sie können in einem Verweis übergeben im Konstruktor MyClass ListenerClass.

Answer 3

Ihr Problem ist die Verwendung von Zuhörern für jeden Zweck in Java gemeinsam:. Wie den Handler Zugriff auf das Objekt lassen, der die Zuhörer oder seine Kollegen mitgeteilt

Generell gibt es zwei Konventionen.

Eine davon ist das Objekt direkt aus dem Event-Objekt zu erhalten. Sie können dies tun mit getSource (). Aber dann würden Sie nur das Widget bekommen, die es getan hat.

Eine weitere Option ist der Hörer Klasse der Lage sein müssen, um die Widgets zuzugreifen. Eine Möglichkeit ist es, eine nicht-statischen inneren Klassen zu verwenden (es wird, hängt davon ab, wie Sie es erklären), wobei in diesem Fall ist es erlaubt, die Mitglieder der enthaltenden Klasse zuzugreifen.

Allerdings ist in diesem Fall Ihre Widgets sind Variablen, die nicht Mitglied (sind Sie sicher, dass Sie das tun wollen?). So Ihre einzige Lösung wäre, Mitglieder sie in der Listner Klasse halten haben, und dann statt der Schaffung der Zuhörer in dem addListener Anruf, einen Listener erstellen, die entsprechenden Widgets übergeben, und den Hörer hinzuzufügen. Der Hörer kann nun diese Widgets durch seine eigenen Verweise auf sie zuzugreifen, die in den Elementen gespeichert sind.