Vous avez quelques choix, chacun avec leurs avantages/inconvénients particuliers.
classes internes anonymes
component.addActionListener(
new ActionListener()
{
public void actionPerformed(final ActionEvent e)
{
outerClassesMethod();
}
});
classe intérieure
class Foo
implements ActionListener
{
public void actionPerformed(final ActionEvent e)
{
outerClassMethod();
}
}
de la classe externe
public class Foo
implements ActionListener
{
private final OuterClass target;
public Foo(final OuterClass t)
{
target = t;
}
public void actionPerformed(final ActionEvent e)
{
target.targetClassMethod();
}
}
classe implémente auditeur
public class OuterClass
implements ActionListener
{
public void actionPerformed(final ActionEvent e)
{
method();
}
// somewhere else in the code
{
component.addActionListener(this);
}
}
Chaque chemin a une bonne et mauvaise à elle.
La classe interne anonyme ne vous permet pas de faire ce que vous demandez, elle ne peut implémenter qu'un seul écouteur.
Les trois autres vous permettront de faire ce que vous voulez (il suffit d'ajouter WindowListener à la liste des outils pour exaple). Vous voulez probablement que la classe interne ou la classe externe implémente le mode d'écoute pour faire ce que vous voulez. Je suggère que parce que l'auditeur est très fortement couplé à votre programme, et vous aurez besoin de faire un grand nombre d'instructions "if" pour déterminer quel contrôle a été utilisé pour effectuer l'action réelle (vous utilisez evt.getSource() pour déterminer quel contrôle était en action et ensuite le communiquer à vos variables d'instance pour voir de quoi il s'agissait). Toutefois, à moins que vous ne soyez en mémoire, comme un téléphone Android, vous ne devriez probablement pas utiliser une seule méthode pour tous les écouteurs car cela peut facilement conduire à un très mauvais code. Si la mémoire est un problème, alors allez-y, mais si ce ne vous êtes mieux de faire l'une des choses suivantes:
- une classe d'écoute par commande
- une classe d'écoute par type d'événement pour tous contrôle
- une classe d'écoute par le contrôle par type d'événement
Je préfère coder de la façon suivante, je trouve être le plus flexible:
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();
}
}
}
Je préfère de cette façon parce qu'elle force les méthodes hors des écouteurs, ce qui signifie que je n'ai qu'un seul endroit pour chercher le code (pas dispersé dans les classes internes). Cela signifie également qu'il est possible que aMethod() et bMethod() puissent être réutilisés - si le code est dans un programme d'écoute qui n'est pas pratique (c'est possible, mais cela n'en vaut pas la peine). Le faire de la manière ci-dessus est également cohérent, et je préfère la cohérence sur la plupart des choses, sauf s'il y a une bonne raison de ne pas le faire. Par exemple sur Android je ne le fais pas car la création de classe est chère (j'ai toujours les méthodes d'appel de l'écouteur seulement, mais la classe elle-même implémente les écouteurs et je fais une instruction if).
À moins que votre action ne délègue à un contrôleur et n'a donc qu'un seul appel de méthode dans la classe anonyme, je ressemble vraiment à cette approche car elle ne fait qu'encombrer le code. Je préfère tout ce qui fait du travail dans une classe séparée – tddmonkey