У вас есть несколько вариантов, каждый со своими конкретными преимуществами / недостатками.
анонимные внутренние классы
component.addActionListener(
new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
outerClassesMethod();
}
});
внутренний класс
class Foo
implements ActionListener
{
public void actionPerformed(final ActionEvent e)
{
outerClassMethod();
}
}
внешний класс
public class Foo
implements ActionListener
{
private final OuterClass target;
public Foo(final OuterClass t)
{
target = t;
}
public void actionPerformed(final ActionEvent e)
{
target.targetClassMethod();
}
}
класс реализует слушатель
public class OuterClass
implements ActionListener
{
public void actionPerformed(final ActionEvent e)
{
method();
}
// somewhere else in the code
{
component.addActionListener(this);
}
}
У каждого пути есть хорошее и плохое.
Анонимный внутренний класс не позволит вам делать то, что вы просите, он может реализовать только один слушатель.
Все остальные три позволят вам делать то, что вы хотите (просто добавьте, WindowListener в список орудий для примера). Вы, вероятно, хотите, чтобы внутренний класс или внешний класс, реализующий способ слушателя, делал то, что вы хотите. Я полагаю, что так как слушатель, вероятно, очень сильно связан с вашей программой, и вам нужно будет сделать большой набор операторов «if», чтобы выяснить, какой элемент управления был использован для выполнения фактического действия (вы используете evt.getSource () чтобы выяснить, какой элемент управления был задействован, а затем сопоставить его с переменными вашего экземпляра, чтобы увидеть, какой это был элемент управления.
Однако, если вы не используете устройство с ограниченной памятью, такое как телефон Android, вам, вероятно, не следует делать один метод для всех слушателей, поскольку это может легко привести к очень плохому коду. Если проблема с памятью, то решите ее, но если это не так, лучше выполнить одно из следующих действий:
- один класс слушателя на элемент управления
- один класс слушателя на тип события для всех элементов управления
- один класс слушателя на элемент управления для каждого типа события
Я предпочитаю кодировать следующим образом, я считаю его наиболее гибким:
public class Outer
extends JFrame
{
private final JButton buttonA;
private final JButton buttonB;
{
buttonA = new JButton("A");
buttonB = new JButton("B");
}
// do not put these in the constructor unless the Outer class is final
public void init()
{
buttonA.addActionListener(new AListener());
buttonB.addActionListener(new BListener());
}
private void aMethod()
{
}
private void bMethod()
{
}
public void AListener
implements ActionListener
{
public void actionPerformed(final ActionEvent evt)
{
aMethod();
}
}
public void BListener
implements ActionListener
{
public void actionPerformed(final ActionEvent evt)
{
bMethod();
}
}
}
Я предпочитаю этот способ, потому что он вытесняет методы из слушателей, что означает, что у меня есть только одно место для поиска кода (не разбросанного по внутренним классам). Это также означает, что возможно, что aMethod () и bMethod () могут быть повторно использованы - если код находится в слушателе, что не практично (это возможно, но не стоит усилий).
Выполнение вышеуказанного способа также является последовательным, и я предпочитаю последовательность по большинству вещей, если нет веской причины не делать этого. Например, на Android я этого не делаю, так как создание класса стоит дорого (у меня все еще есть только методы вызова слушателя, но сам класс реализует слушателей, а я делаю оператор if).