Was sind Java-Ereignisse?

Der Java-Ereignismechanismus besteht aus drei Teilen: Ereignisse, Ereignisquellen und Ereignis-Listener.

1. Ereignisse

Ereignisse erben im Allgemeinen von der Klasse java.util.EventObject und kapseln das Ereignisquellobjekt und ereignisbezogene Informationen.

import java.util.EventObject;  
  
/** 
 * 事件类,用于封装事件源及一些与事件相关的参数. 
 */  
public class CusEvent extends EventObject {  
    private static final long serialVersionUID = 1L;  
    private Object source;//事件源  
      
    public CusEvent(Object source){  
        super(source);  
        this.source = source;  
    }  
  
    public Object getSource() {  
        return source;  
    }  
  
    public void setSource(Object source) {  
        this.source = source;  
    }  
}

2. Ereignisquelle

Die Ereignisquelle ist der Ort, an dem das Ereignis aufgrund einer Änderung eines Attributs oder Status der Ereignisquelle auftritt (z. B BUTTON wird angeklickt, der Wert von TEXTBOX ändert sich usw.) und verursacht das Eintreten eines Ereignisses. Mit anderen Worten: Das entsprechende Ereignisobjekt wird generiert. Da der Ereignis-Listener bei der Ereignisquelle registriert werden muss, sollte die Ereignisquellenklasse über einen Container (Liste, Satz usw.) zur Aufnahme des Listeners verfügen.

/** 
 * 事件源.  
 */  
public class EventSourceObject {  
    private String name;  
    //监听器容器  
    private Set<CusEventListener> listener;  
    public EventSourceObject(){  
        this.listener = new HashSet<CusEventListener>();  
        this.name = "defaultname";  
    }  
    //给事件源注册监听器  
    public void addCusListener(CusEventListener cel){  
        this.listener.add(cel);  
    }  
    //当事件发生时,通知注册在该事件源上的所有监听器做出相应的反应（调用回调方法）  
    protected void notifies(){  
        CusEventListener cel = null;  
        Iterator<CusEventListener> iterator = this.listener.iterator();  
        while(iterator.hasNext()){  
            cel = iterator.next();  
            cel.fireCusEvent(new CusEvent(this));  
        }  
    }  
    public String getName() {  
        return name;  
    }  
    //模拟事件触发器，当成员变量name的值发生变化时，触发事件。  
    public void setName(String name) {  
        if(!this.name.equals(name)){  
            this.name = name;  
            notifies();  
        }        
    }  
}

3. Ereignis-Listener

Der Ereignis-Listener implementiert die java.util.EventListener-Schnittstelle und wird bei der Ereignisquelle registriert Wenn Sie die Quelle ändern, veranlassen Sie den entsprechenden Listener, seine interne Rückrufmethode aufzurufen.

import java.util.EventListener;  
  
/** 
 * 事件监听器，实现java.util.EventListener接口。定义回调方法，将你想要做的事 
 * 放到这个方法下,因为事件源发生相应的事件时会调用这个方法。 
 */  
public class CusEventListener implements EventListener {  
      
    //事件发生后的回调方法  
    public void fireCusEvent(CusEvent e){  
        EventSourceObjecteObject = (EventSourceObject)e.getSource();  
        System.out.println("My name has been changed!");  
        System.out.println("I got a new name,named \""+eObject.getName()+"\"");
    }  
}

Testklasse

public class MainTest {  
   
    public static void main(String[] args) {  
        EventSourceObject object = new EventSourceObject();  
        //注册监听器  
        object.addCusListener(new CusEventListener(){  
            @Override  
            public void fireCusEvent(CusEvent e) {  
                super.fireCusEvent(e);  
            }  
        });  
        //触发事件  
        object.setName("AiLu");  
    }  
}

4. Die Verbindung zwischen Ereignissen, Ereignisquellen und Listenern

Ereignisquelle----- Generieren --- -->Ereignis------>Vom Ereignis-Listener entdeckt------>Geben Sie den Ereignisverarbeitungscode ein

import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class DemoAction extends Frame {//窗口就是事件源
    public DemoAction() {
        this.setTitle("窗口关闭");
        this.setLocation(400, 200);
        this.setSize(360, 280);   
        //给窗口绑定一个事件监听器
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {//事件WindowEvent
                System.exit(0);//关闭窗口事件, 那么退出jvm
            }
        });
        this.setVisible(true);
    }
 
    public static void main(String[] args) {
        new DemoAction();
    }
}

Hauptpunkte der Ereignisverarbeitungsschritte:

(1) Erzeugen Sie einen Listener.

(2) Registrieren Sie den Listener in der entsprechenden Komponente, in der das Ereignis auftritt.

(3) Registrieren Sie den Listener Tritt ein Ereignis auf der Komponente auf, wird das Ereignisobjekt an den Listener zurückgegeben. (4) Der Listener ruft die entsprechende Methode auf, um das Ereignis zu verarbeiten.

Codebeispiele:

public class LoginListener implements ActionListener{
String text;
public void actionPerformed(ActionEvent e){
if("willow".equals(text)){
system.out.println("登录成功！\n");
}
}
}
public class Login(){
public void showFrame(){
//创建窗体
JFrame LFrame = new JFrame();
LFrame.setSize(1000,800);
LFrame.setLocationRelativeTo(null);
LFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
LFrame.setLayout(new FlowLayout());
//创建监听器对象
LoginListener lg = new LoginListener();
//给窗体添加按钮组件
JTextField tf = new JTextField();
LFrame.add(tf);
//给输入框添加监听器
tf.addActionLisener(lg);
tf.text=tf.getText();
}
};

Viele

Java-Schulungsvideos

, alle auf der chinesischen PHP-Website, willkommen zum Online-Lernen!

Das obige ist der detaillierte Inhalt vonWas sind Java-Ereignisse?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!