Explication détaillée des événements en Java avec images et textes

Avant d'apprendre les événements Java, vous devez avoir une certaine compréhension des classes internes Java, des composants Java courants, des conteneurs, des gestionnaires de mise en page et de la boîte à outils de fenêtres abstraites Java. Combiné avec les points de connaissances suivants, Vous pouvez créer quelques programmes de fenêtres simples. (Recommandé : Tutoriel vidéo Java)

Le langage Java utilise le modèle d'événement d'autorisation pour gérer les événements. Selon ce modèle, chaque composant a des événements correspondants, tels qu'un événement de clic pour un bouton, un événement de changement de contenu pour un champ de texte, etc.

Lorsqu'un événement est déclenché, le composant enverra l'événement à chaque écouteur d'événement enregistré par le composant. L'écouteur d'événement définit le traitement des événements correspondant aux différents événements. A ce moment, l'écouteur d'événement Le processeur. appelez différents gestionnaires d'événements en fonction de différentes informations d'événement pour terminer le traitement de cet événement. Les informations d'événement ne seront reçues qu'après le déclenchement de l'écouteur d'événement.

La particularité de ce modèle est que lorsque le composant est déclenché, il ne le traite pas lui-même, mais laisse l'opération de traitement à un tiers. Par exemple, lorsqu'un bouton est cliqué dans l'interface graphique, le bouton est un objet source d'événement. Le bouton lui-même n'a pas le droit de réagir à ce clic. Ce qu'il fait, c'est envoyer des informations à son écouteur enregistré (traitement d'événement (ou, essentiellement). , c'est aussi une classe) à gérer.

Pour comprendre le traitement des événements en Java, vous devez comprendre les trois grandes lignes importantes suivantes.

(1), Événement - événement généré par l'opération de l'utilisateur

(2), Source d'événement - composant qui génère l'événement

(3), Méthode de gestion des événements Poignée d'événement - méthode de gestion des événements

1. Principes de base du traitement des événements

Lorsqu'un événement est déclenché sur un bouton, la machine virtuelle génère un clic L'objet événement est ensuite recherché pour la méthode de traitement associée enregistrée sur le bouton, c'est-à-dire la source de l'événement, et l'objet événement est transmis à cette méthode, et cette méthode est exécutée.

Exemple de programme :

Dans le programme suivant, JButton jb est la source de l'événement, ClickAction est le gestionnaire d'événement, jb.addActionListener(a); un événement click se produit sur la source de l'événement, le code défini dans ClickAction est exécuté.

Le code source est le suivant :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class EventTest {

    public static void main(String[] args) {

        JFrame j = new JFrame("示例程序1");
        //1、事件源jb按钮就是事件源，因为要点击它
        JButton jb = new JButton("click");
        //2、事件处理程序ClickAction表示事件处理程序
        ClickAction a = new ClickAction();
        //3、关联，将事件源和事件处理程序a关联起来，意思是发生点击执行a
        jb.addActionListener(a);
        //将jb源事件添加到窗口中。
        j.getContentPane().add(jb);
        j.pack();
        j.setVisible(true);
    }
}

//事件处理程序，点击就是一个Action事件
class ClickAction implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        System.out.println("hello");
    }
}

2. Objet événement

Dans votre exemple ci-dessus, ActionEvent est un objet événement. Cet événement est généré par JButton lorsque le JButton est enfoncé. L'événement est transmis à l'objet ActionListener enregistré en enregistrant l'écouteur, grâce auquel les informations les plus courantes telles que l'heure à laquelle l'événement se produit et la source de l'événement au moment où l'événement se produit peuvent être obtenues.

Les méthodes courantes d'ActionEvent sont les suivantes :

(1)String getActionCommand() : renvoie la chaîne de commande liée à ce type d'action. Le composant par défaut est le titre.

(2)int getModifiers() : Renvoie les boutons du clavier enfoncés simultanément lorsque cette action se produit.

(3) long getWhen() : Renvoie la forme longue de l'événement lorsque cet événement se produit.

Exemple de programme :
Le code source est le suivant :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class EventTest2 {

    public static void main(String[] args) {

        JFrame j = new JFrame("示例程序2");
        JPanel jp = new JPanel();
        JLabel j1 = new JLabel("请点击");
        JButton jb = new JButton("click");
        JButton jb1 = new JButton("click");
        ClickAction2 a = new ClickAction2();
        jb1.addActionListener(a);//如果jb1上发生了Action事件就执行a里面的代码
        jb.addActionListener(a);
        jp.add(j1);
        jp.add(jb);
        jp.add(jb1);
        j.add(jp);
        j.setSize(400, 200);
        j.setVisible(true);

    }

}

class ClickAction2 implements ActionListener{

    //事件发生时，actionPerformed方法会被虚拟机调用，事件对象回传给该方法
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
         long d = e.getWhen();//事件发生的事件
         Date date = new Date(d);//转化为相应的时间
         System.out.println(date);
         JButton sou = (JButton)e.getSource();//发生的事件源
         sou.setText("点不着");//将点击发生的按钮的按钮设为点不着
         //如果没有设置过ActionCommand，默认得到的是按钮的标题
         String com = e.getActionCommand();
         System.out.println("command is: " +com);
    }

}

3. Types d'événements

Il existe de nombreux événements dans le développement d'interfaces graphiques. . Ces événements Avec EventObject comme niveau supérieur et classe, une arborescence est formée en fonction du type d'événement.

Voir la figure ci-dessous pour plus de détails :

EventObject est la classe parent de toutes les classes d'événements, qui contient deux méthodes :

(1), Object getSource() : L'objet où l'événement s'est produit à l'origine

(2), String toString() : renvoie la représentation sous forme de chaîne de cet EventObject.

Grâce à getSource() : vous pouvez savoir sur quel objet l'événement s'est produit.

Concernant la signification des autres classes d'événements, des explications du code source et des exercices simples pour plusieurs classes seront donnés ci-dessous.

Classe MouseEvent

Les événements de souris sont déclenchés lorsqu'un composant est enfoncé, relâché, cliqué, déplacé ou glissé.

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
public class MouseListenerTest {
    public static void main(String[] args) {
        JFrame j = new JFrame("我的窗口");
        MouL w = new MouL();
        j.addMouseListener(w);
        j.setSize(100, 100);
        j.setVisible(true);
        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

class MouL implements MouseListener{

    @Override
    public void mouseClicked(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("鼠标的位置: " + e.getX() + "," + e.getY());
        System.out.println("点击发生了");
    }

    @Override
    public void mousePressed(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("按下");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("松开");
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("鼠标进入了窗口");
    }

    @Override
    public void mouseExited(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("鼠标离开了窗口");
    }
}

Classe WindowEvent

Les événements de fenêtre seront déclenchés lorsque la fenêtre est ouverte, fermée, agrandie ou réduite

import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.JFrame;

public class WindowsListenerTest {

    public static void main(String[] args) {

        JFrame j = new JFrame("我的窗口");
        WindowL w = new WindowL();
        j.addWindowListener(w);
        j.setSize(100, 100);
        j.setVisible(true);
        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

class WindowL implements WindowListener{

    @Override
    public void windowOpened(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口打开时我执行windowOpened");
    }

    @Override
    public void windowClosing(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("windowClosing");
    }

    @Override
    public void windowClosed(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口关闭时我执行windowClosed");
    }

    @Override
    public void windowIconified(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口最小化时我执行windowIconified");
    }

    @Override
    public void windowDeiconified(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口回复时我执行windowDeiconified");
    }

    @Override
    public void windowActivated(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口变成活动状态时我执行mouseClicked");
    }

    @Override
    public void windowDeactivated(WindowEvent e) {
        // TODO Auto-generated method stub
        System.out.println("窗口变成不活动状态时我执行windowDeactivated");
    }

}

Classe ContainerEvent

Lorsque les événements sont déclenchés lorsqu'un composant est ajouté à un conteneur ou lorsqu'un composant est supprimé d'un conteneur.

import java.awt.event.ContainerListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ContainerEvent {

    public static void main(String[] args) {

        JFrame j = new JFrame("我的窗口");
        ContL w = new ContL();
        JPanel jp = new JPanel();

        jp.addContainerListener(w);

        JButton del = new JButton("删除");
        JButton add = new JButton("add");

        jp.add(add);
        jp.add(del);//触发组件添加了

        jp.remove(del);//触发组件删除了

        j.getContentPane().add(jp);
        j.setSize(100, 100);
        j.setVisible(true);
        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }

}

class ContL implements ContainerListener{

    @Override
    public void componentAdded(java.awt.event.ContainerEvent e) {
        // TODO Auto-generated method stub
        System.out.println("组件添加了");
    }

    @Override
    public void componentRemoved(java.awt.event.ContainerEvent e) {
        // TODO Auto-generated method stub
        System.out.println("组件删除了");
    }

}

FocusEvent

Les clics de souris et autres opérations feront gagner ou perdre le focus d'un composant. Lorsqu'un composant obtient le focus ou perd le focus, l'événement de focus sera déclenché

import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class FocusTest {

    public static void main(String[] args) {

        JFrame j = new JFrame("key test");
        JPanel jp = new JPanel();
        JButton j1 = new JButton("1");
        JButton j2 = new JButton("2");
        j1.addFocusListener(new FocusL());
        j2.addFocusListener(new FocusL());
        jp.add(j1);
        jp.add(j2);
        j.add(jp);
        j.setSize(600, 500);
        j.setVisible(true);
    }

}

class FocusL implements FocusListener{

    @Override
    public void focusGained(FocusEvent e) {
        //得到FocusEvent发生时的对象，转化为按钮
        // TODO Auto-generated method stub
        JButton j = (JButton)e.getSource();
        //得到按钮的标题
        String title = j.getText();
        System.out.println("focusGained：按钮" + title + "获得焦点");
    }

    @Override
    public void focusLost(FocusEvent e) {
        // TODO Auto-generated method stub
        JButton j = (JButton)e.getSource();
        String title = j.getText();
        System.out.println("focusLost:按钮" + title + "失去焦点");
    }

}

4. Plusieurs auditeurs

Généralement, la source de l'événement peut De nombreux types d'événements différents sont générés, de sorte que de nombreux types différents d'écouteurs peuvent être enregistrés (déclenchés).

Plusieurs auditeurs peuvent être enregistrés sur un composant source d'événement, et un auditeur peut être enregistré sur plusieurs sources d'événements différentes.

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

import javax.swing.JFrame;
import javax.swing.JTextField;

public class MultiListenerTest {

    public static void main(String[] args) {

        JFrame a = new JFrame("事件处理");
        JTextField jf = new JTextField();
        a.add(jf, "South");
        MouseM m = new MouseM();

        //同一事件源上注册两个事件监听程序
        //鼠标的监听程序如点击等
        a.addMouseListener(m);

        //鼠标移动的监听程序
        a.addMouseMotionListener(m);

        a.setSize(200, 200);
        a.setVisible(true);
    }

}

class MouseM implements MouseMotionListener, MouseListener{

    @Override
    public void mouseClicked(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("clicked" + "x:" + e.getX() + ",y:" + e.getY());
    }

    @Override
    public void mousePressed(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("mousePressed");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("mouseRelsased");
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("mouseEntered");
    }

    @Override
    public void mouseExited(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("mouseExited");
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("拖动:" + e.getPoint());
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        // TODO Auto-generated method stub
        System.out.println("移动:" + e.getPoint());
    }

}

5. Adaptateur d'événement

Pour simplifier la programmation, JDK définit les classes d'implémentation correspondantes pour la plupart des interfaces d'écoute d'événements - les classes d'adaptateur d'événements, dans l'adaptateur, implémentent toutes les méthodes. dans l'interface d'écoute correspondante, mais ne fait rien.

Ainsi, la classe d'écoute définie peut hériter de la classe de l'adaptateur d'événements et remplacer uniquement les méthodes requises.

possède les adaptateurs suivants :

- ComponentAdapter (adaptateur de composant)

 - ContainerAdapter (容器适配器)

 - FocusAdapter (焦点适配器)

 - KeyAdapter (键盘适配器)

 - MouseAdapter (鼠标适配器)

 - MouseMotionAdapter (鼠标运动适配器)

 - WindowAdapter (窗口适配器)

鼠标适配器示例程序：MouseListener中由多个方法，但在这里只实现了mouseClicked()

package 图形界面设计;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JFrame;

public class AdapterTest {

    public static void main(String[] args) {

        JFrame z = new JFrame("事件适配器测试");
        z.setSize(500, 400);

        MouseLS a = new MouseLS();

        //注册z上的鼠标事件处理程序，发生点击等事件执行a里的代码
        z.addMouseListener(a);
        z.setVisible(true);
        z.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

class MouseLS extends MouseAdapter{

    public void mouseClicked(MouseEvent e){

        // 打印出鼠标点击时的x点和y点的坐标
        System.out.println("鼠标点击了:" + e.getX() + "," + e.getY());
    }

}

更多java知识请关注java基础教程栏目。

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!