Quels comportements les objets peuvent-ils reconnaître et auxquels ils peuvent réagir ?

Les comportements que les objets peuvent reconnaître et auxquels ils peuvent répondre sont des « événements ». Les comportements qu'un objet peut reconnaître et auxquels il peut répondre sont appelés événements. Les événements sont des actions qu'un objet peut reconnaître et détecter. Lorsque cette action se produit sur un objet, son événement correspondant sera déclenché.

Résumé des événements Java

Modèle de traitement des événements

Pour les applications GUI, le traitement des événements est essentiel, nous devons donc maîtriser le modèle de traitement des événements avec compétence. Pour les événements, nous devons comprendre deux termes : objet source d’événement et objet écouteur. Nous pouvons le comprendre grossièrement littéralement. Expliquons-le systématiquement :

• Un objet écouteur est une instance d'une classe qui implémente une interface d'écoute spécifique

• Une source d'événement est un objet qui peut enregistrer des objets d'écoute et envoyer des objets d'événement

• Lorsqu'un événement se produit, la source d'événement transmet l'objet d'événement à toutes les inscriptions. L'auditeur

• L'objet écouteur utilisera les informations contenues dans l'objet événement pour décider comment répondre à l'événement

Nous allons d'abord nous inscrire auprès de l'objet source de l'événement afin que lorsque l'événement est déclenché, le système peut accéder à l'écouteur correspondant via la source de l'événement. Comme indiqué ci-dessous :

Lorsque la source de l'événement déclenche l'événement, le système encapsule les informations pertinentes de l'événement dans un objet événement du type correspondant et l'envoie à l'événement. source enregistrée. Comme indiqué ci-dessous :

Lorsque l'objet événement est envoyé à l'écouteur, le système appelle la méthode de traitement d'événement correspondante de l'écouteur pour traiter l'événement, c'est-à-dire pour répondre . Comme indiqué ci-dessous :

Remarque : Il existe une relation « plusieurs-à-plusieurs » entre l'auditeur et la source de l'événement.

Hiérarchie des objets événementiels

Le niveau le plus élevé de l'objet événementiel est java.util.EventObject, la classe racine à partir de laquelle tous les objets d'état d'événement seront dérivés. En plus des classes héritées de la classe Object, cette classe possède également la méthode getSource(), dont la fonction est de renvoyer l'objet où l'événement s'est produit à l'origine.

Sauf que cette classe est dans le package util, les autres sont dans le package java.awt, java.awt.event ou java.swing, java.swing.event. Il convient de noter que ce n'est pas le cas. signifie que le contrôle Swing utilise uniquement les événements Swing.

La classe AWSTEvent fournit la méthode getID() pour renvoyer l'identifiant de la nature de l'événement. Par exemple, si un événement de souris se produit, vous pouvez savoir s'il s'agit d'un clic, d'un glissement, d'une pression ou d'une autre opération.

Description de plusieurs classes d'événements couramment utilisées :

• EventObject : la super classe de toutes les classes d'événements. La méthode la plus importante - getSource(), renvoie l'objet qui a généré un événement

• AWTEvent : la super classe de toutes les classes d'événements AWT. La méthode la plus importante - getID(), renvoie le numéro d'identification d'un événement. L'ID de l'événement est un entier, qui spécifie le type d'événement, comme un événement de bouton ou un événement de clic de souris

<.>
• ActionEvent : événements qui se produisent lorsqu'un composant est activé

• AdjustmentEvent : événements qui se produisent lorsqu'un composant réglable (comme le déplacement d'une barre de défilement) est ajusté

• ComponentEvent : un événement de haut niveau qui se produit lors de la manipulation d'un composant

• ContainerEvent : se produit lorsqu'un composant est ajouté ou supprimé d'un conteneur

• InputEvent : généré par un périphérique d'entrée. Un événement de haut niveau

• ItemEvent : se produit lors de la sélection à partir d'un élément de sélection, d'une case à cocher ou d'une liste

• KeyEvent : se produit lors de l'utilisation du clavier

• MouseEvent : se produit lors de l'utilisation de la souris

• PaintEvent : un événement qui se produit lors du dessin d'un composant

• TextEvent : se produit lorsque le texte est modifié

• WindowEvent : un événement se produit lorsque la fenêtre est manipulée, comme maximiser ou réduire une fenêtre.

Hiérarchie des objets d'écoute

Un objet d'écoute est une instance d'une classe qui implémente une interface d'écoute spécifique, puis l'interface d'écoute C'est quoi nous sommes préoccupés. L'interface de niveau supérieur de l'interface d'écoute est java.util.EventListener. Cette interface est l'interface de marque que toutes les interfaces d'écoute d'événements doivent étendre. Ce qui est surprenant, c'est que cette interface est complètement vide. Elle ne contient aucune définition d'une méthode abstraite. Lorsque je vérifie le code source, elle est vide !

• La classe d'écoute d'événement (la classe à laquelle appartient l'objet d'écoute) doit implémenter l'interface d'écoute d'événement ou hériter de la classe d'adaptateur d'écoute d'événement.

• L'interface d'écoute d'événements définit les méthodes qui doivent être implémentées pour gérer les événements.

• La classe d'adaptateur d'écouteur d'événements est une implémentation simple de l'interface d'écoute d'événements. Le but est de réduire la charge de travail de programmation.

La méthode de dénomination des interfaces des écouteurs d'événements est : XXListener, et en Java, ces interfaces ont déjà été définies. Utilisé pour être implémenté, il définit le gestionnaire d'événements (c'est-à-dire le prototype de la méthode de gestion des événements, cette méthode doit être réimplémentée).

Par exemple : interface ActionListener, interface MouseListener, interface WindowListener, interface KeyListener, interface ItemListener, interface MouseMotionListener, interface FocusListener, interface ComponentListener, etc.

Source de l'événement

Les événements sont initialement générés par une source d'événement, qui peut être un composant GUI Java Bean ou un objet capable de générer des événements. Dans le cas d'un composant GUI, la source d'événement est soit un homologue du composant (par exemple). Abstract Window Toolkit [awt] composants GUI par exemple) ou le composant lui-même (pour les composants Swing).

En Java, le type d'événements que chaque composant générera a été défini. En d’autres termes, pour tout événement, les composants capables de le produire sont déjà déterminés.

Événements

AWT divise les événements en événements de bas niveau et événements sémantiques.

• Les événements sémantiques sont des événements qui représentent les actions des utilisateurs.

• Les événements de bas niveau sont les événements qui forment ces événements.

Classes d'événements sémantiques communes dans le package java.awt.event :

• ActionEvent (correspondant au clic sur un bouton, à la sélection de menu, à la sélection d'un élément de liste ou ENTRÉE dans la zone de texte)

• AdjustmentEvent (l'utilisateur ajuste la barre de défilement)

• ItemEvent (l'utilisateur sélectionne un élément dans une case à cocher ou zone de liste) Item)

Cinq classes d'événements de bas niveau couramment utilisées :

• KeyEvent (une touche est enfoncée ou relâchée)

• MouseEvent (bouton de la souris enfoncé, relâché, déplacé ou glissé)

• MouseWheelEvent (molette de la souris tournée)

• FocusEvent (un composant gagne ou perd le focus)

• WindowEvent (l'état de la fenêtre est modifié)

paquet java.awt.event Couramment Les classes d'adaptateur d'événements utilisées définies dans incluent les éléments suivants :

　1. ComponentAdaptateur (Adaptateur de composants)

　2. ContainerAdapter(Adaptateur de conteneur)

　3. FocusAdaptateur (Adaptateur de mise au point)

　4. KeyAdapter (adaptateur de clavier)

　5. MouseAdapter (Adaptateur de souris)

　6. MouseMotionAdapter (Adaptateur de mouvement de la souris)

　7． WindowAdapter (Window Adapter)

Relation correspondante entre les sources d'événements et les auditeurs

La figure suivante est le diagramme de relation correspondant dans le développement Java réel :

Tableau de comparaison des objets d'événement et des auditeurs communs :

常见事件源与监听器接口对照表

监听器接口	事件源
ActionListener	AbstractButton JcomboBox JTextField Timer
AdjustmentListener	JscrollBar
ItemListener	AbstractButton JComboBox
FocusListener	Component
KeyListener	Component
MouseListener	Component
MouseMotionListener	Component
MouseWheelListener	Component
WindowListener	Window
WindowFocusListener	Window
WindowStateListener	Window

Suggestion : Pour comprendre cette partie, vous devez d'abord comprendre la relation générale entre les composants visuels Java et les conteneurs, ce qui facilitera notre compréhension.

Étapes habituelles de développement d'un programme

En tant que développeur de programme, ce que nous devons faire est de créer un objet écouteur d'événement et de le placer dans le composant où l'événement est activé (nouveau) Pour vous inscrire. La soi-disant création d'un objet écouteur d'événement signifie créer une classe, et cette classe doit implémenter une interface sous la forme de XXListener (ou hériter d'une "classe qui a implémenté XXListener"). Bien entendu, implémenter cette interface signifie remplacer la méthode. de XXListener.

Par exemple, pour ActionListener, il n'y a qu'une seule méthode actionPerformed :

class B1 implements ActionListener{// 实现ActionListener
    @override
    public void actionPerformed(ActionEvent e){
	//重写actionPerformed     
        //do somthing....
    }
}

Enregistrer l'écouteur d'événement dans le composant de l'événement activé : c'est-à-dire appeler une méthode sous la forme addXXListener() .

Par exemple :

Button b1 = new Button("Button 1");
b1.addActionListener(new B1()); //注册事件监听器

b1 est le composant de l'événement activé De cette façon, lorsque l'événement est activé, le flux de traitement est le suivant : Puisque l'écouteur d'événement a été enregistré via. addActionListener, donc, la méthode de traitement d'événement spécifique, à savoir la fonction actionPerformed(), sera appelée. De cette façon, le résultat de l’exécution dépend de ce que fait spécifiquement actionPerformed.

Un auditeur n'écoute qu'une source d'événement spécifique, nous pouvons alors utiliser des objets anonymes pour enregistrer l'auditeur.

Par exemple :

JButton b=new JButton("jjjj");
b.addActionListener(new ActionListener() {
	@Override
	public void actionPerformed(ActionEvent e) {
		//重写actionPerformed     
        //do somthing....
	}
});

Les étapes générales pour gérer chaque événement de composant dans Java Swing sont :
　1. Créez un nouveau composant (tel que JButton).
　2. Ajoutez le composant au panneau correspondant (tel que JPanel).
　3. Enregistrez un écouteur pour écouter les événements générés par la source d'événements (comme l'utilisation d'ActionListener pour répondre au clic de l'utilisateur sur un bouton).
　4. Définissez la méthode pour gérer l'événement (comme définir la méthode correspondante dans actionPerformed dans ActionListener).

La première façon de créer une classe d'écoute ci-dessus peut être une classe interne, et la deuxième façon de créer un auditeur est une classe interne anonyme, facile à comprendre.

Conception de séparation de la réponse et de l'interface

Nous écrivons ensemble le traitement des événements et l'interface. L'un n'est pas pratique à maintenir et l'autre entraînera une surcharge du fichier de code actuel. Par conséquent, je vous suggère toujours de séparer les événements correspondants de l'interface, ce qui peut non seulement compenser les deux premiers défauts, mais également améliorer la réutilisabilité du code. Mais n’ignorez pas l’utilisation de classes internes et de classes internes anonymes, car chacune a ses propres avantages et inconvénients, et nous devons les considérer de manière globale.

Le package Swing fournit un mécanisme très pratique pour encapsuler des commandes et les connecter à plusieurs sources d'événements. Il s'agit de l'interface Action. Une action est un objet qui encapsule :

• Description de la commande (une chaîne de texte et une icône facultative)

• Exécution de la commande Obligatoire paramètres (par exemple, la couleur demandée à changer dans l'exemple répertorié)

Veuillez vous référer à l'API pour plus de détails.

Il est à noter qu'Action est une interface, pas une classe. Toutes les classes qui implémentent cette interface doivent implémenter 7 des méthodes. Heureusement, il existe une classe qui implémente toutes les méthodes de cette interface à l'exception de la méthode actionPerformed, qui est AbstractAction. Cette classe stocke toutes les paires nom/valeur et gère les écouteurs de changement de propriété. Nous pouvons directement étendre la classe AbstractAction et implémenter la méthode actionPerformed dans la classe étendue.

Une meilleure méthode de conception que j'ai vue est la suivante : la classe d'écouteur hérite de javax.swing.AbstractAction, et lors de l'enregistrement sur le composant, le composant est transmis à l'écouteur.

Écouteur :

public class AC_temp extends AbstractAction{
	private static final long serialVersionUID = 1L;
	MainFrame main;
	public AC_EditVideoInfo(MainFrame temp,Color color) {
		main=temp;
		putValue(Action.NAME, "name");
		putValue(Action.SMALL_ICON, new ImageIcon("images/edit.png"));
		putValue(Action.SHORT_DESCRIPTION, "description");
                putValue("color",color);
                //....
	}
	@Override
	public void actionPerformed(ActionEvent e) {
		// do something
	}
}

Source de l'événement :

组件.addActionListener(new AC_EditVideoInfo(this));//注册监听器

Créez un écouteur contenant un appel de méthode

java.beans. est un gestionnaire d'événements du point de vue du nommage. L'explication donnée par l'API officielle est la suivante : La classe EventHandler prend en charge la génération dynamique d'écouteurs d'événements. Les méthodes de ces écouteurs exécutent une instruction simple impliquant l'objet événement entrant et l'objet cible.

Pour une explication plus détaillée, reportez-vous à : ————————>>>>>>>>>

Exemple d'utilisation EventHandler :

La façon la plus simple d'utiliser EventHandler est d'installer un écouteur et d'appeler une méthode sur l'objet cible sans paramètres. Dans l'exemple suivant, un ActionListener est créé et appelle la méthode toFront sur une instance javax.swing.JFrame.

myButton.addActionListener(
    (ActionListener)EventHandler.create(ActionListener.class, frame, "toFront"));

Lorsque myButton est enfoncé, l'instruction frame.toFront() sera exécutée. En définissant une nouvelle implémentation de l'interface ActionListener et en ajoutant son instance au bouton, l'utilisateur peut obtenir le même effet, avec une sécurité de type supplémentaire au moment de la compilation :

//Equivalent code using an inner class instead of EventHandler.
myButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        frame.toFront();
    }
});

L'autre utilisation la plus simple d'EventHandler est celle de l'écouteur. Extrait la valeur de la propriété du premier paramètre de la méthode dans l'interface d'écoute (généralement un objet événement) et l'utilise pour définir la valeur de la propriété dans l'objet cible. Dans l'exemple suivant, un ActionListener est créé et définit la propriété nextFocusableComponent de l'objet cible (myButton) sur la valeur de la propriété « source » de l'événement.

EventHandler.create(ActionListener.class, myButton, "nextFocusableComponent", "source")

Cela correspondrait à l'implémentation de classe interne suivante :

//Equivalent code using an inner class instead of EventHandler.
new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        myButton.setNextFocusableComponent((Component)e.getSource()); 
    }
}

Il est également possible de créer un EventHandler qui transmet simplement l'objet événement entrant à l'action cible. Si le quatrième paramètre dans EventHandler.create est une chaîne vide, l'événement est délivré comme suit :

EventHandler.create(ActionListener.class, target, "doActionEvent", "")

Cela correspondra à l'implémentation de classe interne suivante :

//Equivalent code using an inner class instead of EventHandler.
new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        target.doActionEvent(e);
    }
}

EventHandler 最常见的用法可能是从事件对象的 source 中提取属性值，并将此值设置为目标对象的属性值。在以下示例中，将创建一个 ActionListener，它将目标对象的 "label" 属性设置为事件源的 "text" 属性的值（"source" 属性的值）。

EventHandler.create(ActionListener.class, myButton, "label", "source.text")

这将对应于以下内部类实现：

//Equivalent code using an inner class instead of EventHandler.
new ActionListener {
    public void actionPerformed(ActionEvent e) {
        myButton.setLabel(((JTextField)e.getSource()).getText()); 
    }
}

可以使用以 "." 字符分隔的任意数量的属性前缀来“限定”事件属性。采用出现在 "." 字符前面的“限定”名称作为将应用于事件对象的属性名称，最左边的最先应用。
例如，以下动作侦听器

EventHandler.create(ActionListener.class, target, "a", "b.c.d")

可以写成以下内部类（假定所有属性都有规范的获取方法并返回适当的类型）：

//Equivalent code using an inner class instead of EventHandler.
new ActionListener {
    public void actionPerformed(ActionEvent e) {
        target.setA(e.getB().getC().isD()); 
    }
}

也可以使用以 "." 字符分隔的任意数量的属性前缀来“限定”目标属性。例如，以下动作侦听器：

EventHandler.create(ActionListener.class, target, "a.b", "c.d")

可以写成以下内部类（假定所有属性都有规范的获取方法并返回适当的类型）：

//Equivalent code using an inner class instead of EventHandler.
   new ActionListener {
     public void actionPerformed(ActionEvent e) {
         target.getA().setB(e.getC().isD()); 
    }
}

由于 EventHandler 最终依赖反射来调用方法，所以建议不要以重载方法为目标。例如，如果目标是类 MyTarget 的一个实例，而 MyTarget 定义如下：

public class MyTarget {
     public void doIt(String);
     public void doIt(Object);
   }

那么方法 doIt 被重载。EventHandler 将基于源调用恰当的方法。如果源为 null，那么两个方法都可以，具体调用哪个方法是不确定的。因此，建议不要以重载方法为目标。

更多相关知识，请访问：PHP中文网！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!