Qu'est ce qu'un EventListener contrairement à un Gestionnaire d'événements?

Au risque de ne pas comprendre la question entièrement, je voudrais proposer une autre explication possible.

Parler de classes Java a une EventListener et .NET est un Gestionnaire d'événements. Les deux ont le même but: la gestion des événements. Cependant il existe des différences dans la mise en œuvre. Il pourrait être dit que .NET de la gestion des événements est un niveau d'abstraction supérieur à Java, les écouteurs d'événement.

La Java EventListener est "un marquage de l'interface que toutes les interfaces de listener d'événements doit s'étendre" (c'est à dire MouseListener). L' .NET du Gestionnaire d'événements est un délégué, un typage fort pointeur vers une méthode qui traite d'un événement.

De façon plus générale, un écouteur d'événement est un objet qui implémente une interface pour la gestion des événements pendant un gestionnaire d'événement est juste une méthode qui traite d'un événement. Généralement parlant, les écouteurs d'événement met en œuvre un Modèle De Conception Observateur et des gestionnaires d'événement de cacher toute la plomberie de ce motif. Par conséquent, l'écriture d'un écouteur d'événement est beaucoup plus impliqué et a tendance à être plus verbale que d'écrire un gestionnaire d'événements.

Je vous recommande de lire le Modèle De Conception Observateur par Microsoft pour obtenir une meilleure compréhension de celui-ci.

Donc, pour mettre en œuvre un gestionnaire d'événement, il vous suffit de désigner un délégué à l'événement d'un objet que vous souhaitez gérer. I. e.

Button.Click += new EventHandler(MyButton_Click); 

où MyButton_Click est une méthode (il pourrait être dans votre classe ou ailleurs) qui a sa propre signature et gère en fait l'événement, c'est à dire

private void MyButton_Click(object sender, EventArgs e)
{
    doSomething();
}

Pour atteindre le même avec les écouteurs d'événements en Java, vous pouvez écrire quelque chose comme ceci (pardonnez-moi si je fais des erreurs, depuis que je suis en train d'écrire à partir de la mémoire):

public class MyClass
{
    Button myButton;

    MyClass()
    {
        ...
        myButton.addMouseListener(new ButtonHandler());
    }

    public class ButtonHandler implements MouseListener
    {
        public void mousePressed(MouseEvent e) {}
        public void mouseReleased(MouseEvent e) {}
        public void mouseEntered(MouseEvent e) {}
        public void mouseExited(MouseEvent e) {}

        public void mouseClicked(MouseEvent e)
        {
           doSomething("Mouse clicked", e);
        }
    }
}

Naturellement, il existe de nombreuses façons de mettre en œuvre cette commune pattern observer, y compris la mise en œuvre de EventListener interfaces dans la classe elle-même, dans les classes internes anonymes classes, adaptateurs, etc. Mais cela devrait le démontrer.

OriginalL'auteur Ruslan