Welche Verhaltensweisen können Objekte erkennen und auf sie reagieren?

Die Verhaltensweisen, die Objekte erkennen und auf die sie reagieren können, sind „Ereignisse“. Verhaltensweisen, die ein Objekt erkennen und auf die es reagieren kann, werden als Ereignisse bezeichnet. Dabei handelt es sich um Aktionen, die ein Objekt erkennen und erkennen kann. Wenn diese Aktion an einem Objekt auftritt, wird das entsprechende Ereignis ausgelöst.

Java-Ereigniszusammenfassung

Ereignisverarbeitungsmodell

Für GUI-Anwendungen ist die Ereignisverarbeitung unerlässlich, daher müssen wir das Ereignisverarbeitungsmodell kompetent beherrschen. Für Ereignisse müssen wir zwei Begriffe verstehen: Ereignisquellenobjekt und Listenerobjekt. Aus der wörtlichen Bedeutung können wir uns eine ungefähre Vorstellung machen. Lassen Sie uns das System unten erklären:

• Ein Listener-Objekt ist eine Instanz einer Klasse, die eine bestimmte Listener-Schnittstelle implementiert.

• Die Ereignisquelle ist eine Ereignisquelle, die dies kann Registrieren Sie sich zum Abhören. Die Ereignisquelle gibt das Ereignisobjekt an alle registrierten Zuhörer weiter, wenn das Ereignis auftritt. Das Zuhörerobjekt verwendet die Informationen im Ereignisobjekt, um zu entscheiden, wie auf das Ereignis reagiert wird Objekt an das Ereignisquellenobjekt an, sodass das System beim Auslösen des Ereignisses über die Ereignisquelle auf den entsprechenden Listener zugreifen kann. Wie unten gezeigt:

• Wenn die Ereignisquelle das Ereignis auslöst, kapselt das System die relevanten Informationen des Ereignisses in ein Ereignisobjekt des entsprechenden Typs und sendet sie an den entsprechenden Listener, der bei der Ereignisquelle registriert ist. Wie unten gezeigt:
Wenn das Ereignisobjekt an den Listener gesendet wird, ruft das System die entsprechende Ereignisverarbeitungsmethode des Listeners auf, um das Ereignis zu verarbeiten, dh zu reagieren. Wie unten gezeigt:

Hinweis: Es besteht eine „viele-zu-viele“-Beziehung zwischen dem Zuhörer und der Ereignisquelle.

Hierarchie der Ereignisobjekte

Die höchste Ebene unter den Ereignisobjekten ist java.util.EventObject, die Stammklasse, von der alle Ereignisstatusobjekte abgeleitet werden. Zusätzlich zu den von der Object-Klasse geerbten Klassen verfügt diese Klasse auch über die Methode getSource(), deren Funktion darin besteht, das Objekt zurückzugeben, an dem das Ereignis ursprünglich aufgetreten ist.

Außer dass diese Klasse im util-Paket enthalten ist, befinden sich die anderen im Paket java.awt, java.awt.event oder im Paket java.swing, java.swing.event. Es ist erwähnenswert, dass Swing-Steuerelemente nur Swing-Ereignisse verwenden. .

Die AWTEvent-Klasse stellt die Methode getID() bereit, um die Kennung der Ereignisart zurückzugeben. Wenn beispielsweise ein Mausereignis auftritt, können Sie herausfinden, ob es sich um einen Klick, ein Ziehen, ein Drücken oder einen anderen Vorgang handelte.

Beschreibung mehrerer häufig verwendeter Ereignisklassen:

EventObject: die Superklasse aller Ereignisklassen. Die wichtigste Methode – getSource(), gibt das Objekt zurück, das ein Ereignis generiert hat

AWTEvent: die Superklasse aller AWT-Ereignisklassen. Die wichtigste Methode – getID() – gibt die ID-Nummer eines Ereignisses zurück, die den Typ des Ereignisses angibt, z. B. ein Schaltflächenereignis oder ein Mausklickereignis.

ActionEvent: Ein Ereignis das auftritt, wenn eine Komponente aktiviert wird

• AdjustmentEvent: ein Ereignis, das beim Anpassen einer anpassbaren Komponente auftritt (z. B. Verschieben einer Bildlaufleiste)

• ComponentEvent: ein Ereignis auf hoher Ebene, das auftritt, wenn eine Komponente manipuliert wird

• ContainerEvent: Tritt auf, wenn eine Komponente zu einem Container hinzugefügt oder daraus entfernt wird

• InputEvent: Ein von einem Eingabegerät generiertes Ereignis auf hoher Ebene

• ItemEvent: Tritt auf, wenn aus einem Auswahlelement, einem Kontrollkästchen oder einer Liste ausgewählt wird

• KeyEvent: Tritt auf, wenn die Tastatur bedient wird.

• MouseEvent: Tritt auf, wenn die Maus verwendet wird

WindowEvent: Ein Ereignis tritt ein, wenn ein Fenster manipuliert wird, beispielsweise das Maximieren oder Minimieren eines Fensters.
• Die Hierarchie der Listener-Objekte

Ein Listener-Objekt ist eine Instanz einer Klasse, die eine bestimmte Listener-Schnittstelle implementiert. Daher geht es uns um die Listener-Schnittstelle. Die Schnittstelle der obersten Ebene in der Listener-Schnittstelle ist java.util.EventListener. Diese Schnittstelle ist die Markierungsschnittstelle, die alle Ereignis-Listener-Schnittstellen erweitern müssen. Überraschend ist, dass diese Schnittstelle völlig leer ist. Es gibt keine Definition einer abstrakten Methode. Wenn ich den Quellcode überprüfe, ist er leer.
Die Ereignis-Listener-Klasse (die Klasse, zu der das Listener-Objekt gehört) muss die Ereignis-Listener-Schnittstelle implementieren oder die Ereignis-Listener-Adapterklasse erben.
Die Ereignis-Listener-Schnittstelle definiert die Methoden, die zur Verarbeitung von Ereignissen implementiert werden müssen.
Die Event-Listener-Adapterklasse ist eine einfache Implementierung der Event-Listener-Schnittstelle. Der Zweck besteht darin, den Programmieraufwand zu reduzieren.

Die Schnittstellenbenennungsmethode von Ereignis-Listenern lautet: XXListener. In Java wurden diese Schnittstellen bereits definiert. Wird zur Implementierung verwendet und definiert den Ereignishandler (dh den Prototyp der Ereignisbehandlungsmethode. Diese Methode muss erneut implementiert werden).

Zum Beispiel: ActionListener-Schnittstelle, MouseListener-Schnittstelle, WindowListener-Schnittstelle, KeyListener-Schnittstelle, ItemListener-Schnittstelle, MouseMotionListener-Schnittstelle, FocusListener-Schnittstelle, ComponentListener-Schnittstelle usw.

Ereignisquelle

Ereignisse werden zunächst durch Ereignisquellen und das Ereignis generiert Quelle kann eine GUI-Komponente sein. Java Eine Bean oder ein Objekt, das Ereignisse generieren kann. Im Fall einer GUI-Komponente ist die Ereignisquelle entweder der Peer der Komponente (für Abstract Window Toolkit [awt] GUI-Komponenten) oder die Komponente selbst (für Swing). Komponenten).

In Java wurde definiert, welche Art von Ereignissen jede Komponente generiert. Mit anderen Worten: Für jedes Ereignis steht bereits fest, aus welchen Komponenten es entstehen kann.

Ereignisse

AWT unterteilt Ereignisse in Low-Level-Ereignisse und semantische Ereignisse.

• Semantische Ereignisse sind Ereignisse, die Benutzeraktionen darstellen.

• Ereignisse auf niedriger Ebene sind die Ereignisse, die diese Ereignisse bilden.

Gemeinsame semantische Ereignisklassen im java.awt.event-Paket:

• ActionEvent (entspricht dem Klicken auf eine Schaltfläche, der Menüauswahl, dem ausgewählten Listenelement oder der EINGABETASTE im Textfeld)

• AdjustmentEvent (Benutzer passt das an Bildlaufleiste)

• ItemEvent (der Benutzer wählt ein Element aus einem Kontrollkästchen oder Listenfeld aus)

5 häufig verwendete Ereignisklassen auf niedriger Ebene:

• KeyEvent (eine Taste wird gedrückt oder losgelassen)

• MouseEvent (die Maustaste wird gedrückt, losgelassen, bewegt oder gezogen)

• MouseWheelEvent (das Mausrad wird gedreht)

• FocusEvent (eine Komponente erhält oder verliert den Fokus)

• WindowEvent (der Fensterstatus wird geändert (Änderung)

Zu den im Paket java.awt.event definierten allgemeinen Ereignisadapterklassen gehört Folgendes:

　1. ComponentAdapter(Komponentenadapter)

　2. ContainerAdapter(Container-Adapter)

　3. FocusAdapter (Fokus-Adapter)

　4. KeyAdapter (Tastaturadapter)

　5． MouseAdapter (Mausadapter)

　6． MouseMotionAdapter (Mausbewegungsadapter)

　7． WindowAdapter (Fensteradapter)

Die entsprechende Beziehung zwischen Ereignisquellen und Listenern

Das folgende Bild ist das entsprechende Beziehungsdiagramm in der tatsächlichen Java-Entwicklung:

Vergleichstabelle für gemeinsame Ereignisobjekte und Listener:

Gemeinsame Ereignisquellen und Vergleichstabelle der Listener-Schnittstelle

Listener-Schnittstelle	Ereignisquelle
ActionListener	AbstractButton JcomboBox JTextField Timer
AdjustmentListener	JscrollBar
ItemListener	AbstractButton JComboBox
FocusListener	Component
KeyListener	Component
MouseListener	Component
MouseMotionListener	Komponente
MouseWheelListener	Komponente
WindowListener	Window
WindowFocusListener	Window
WindowStateListener	Window

Vorschlag: Um diesen Teil zu verstehen, müssen Sie zunächst die allgemeine Beziehung zwischen visuellen Java-Komponenten und Containern verstehen, was unser Verständnis erleichtert.

Übliche Programmentwicklungsschritte

Als Programmentwickler müssen wir ein Ereignis-Listener-Objekt erstellen und es in der Komponente registrieren, die ein (neues) Ereignis aktiviert. Die sogenannte Erstellung eines Ereignis-Listener-Objekts bedeutet das Erstellen einer Klasse, und diese Klasse muss eine Schnittstelle in Form von XXListener implementieren (oder „eine Klasse erben, die XXListener implementiert hat“). Natürlich bedeutet die Implementierung dieser Schnittstelle, die Methode zu überschreiben von XXListener.

Zum Beispiel gibt es für ActionListener nur eine actionPerformed-Methode:

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

Registrieren Sie den Ereignis-Listener in der Komponente des aktivierten Ereignisses: Rufen Sie also eine Methode wie addXXListener() auf.

Zum Beispiel:

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

b1 ist die Komponente des aktivierten Ereignisses. Auf diese Weise ist der Verarbeitungsablauf wie folgt: Da der Ereignis-Listener über addActionListener registriert wurde, erfolgt die spezifische Ereignisverarbeitung aufgerufene Methode, also die Funktion actionPerformed(). Auf diese Weise hängt das Ausführungsergebnis davon ab, was actionPerformed konkret tut.

Ein Listener hört nur auf eine bestimmte Ereignisquelle. Dann können wir anonyme Objekte verwenden, um den Listener zu registrieren.

Zum Beispiel:

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

Die allgemeinen Schritte zur Behandlung jedes Komponentenereignisses in Java Swing sind:
　1. Erstellen Sie eine neue Komponente (z. B. JButton).
　2. Fügen Sie die Komponente dem entsprechenden Panel hinzu (z. B. JPanel).
　3. Registrieren Sie einen Listener, um auf Ereignisse zu warten, die von der Ereignisquelle generiert werden (z. B. indem Sie ActionListener verwenden, um auf das Klicken des Benutzers auf eine Schaltfläche zu reagieren).
　4. Definieren Sie die Methode zur Behandlung des Ereignisses (z. B. Definieren der entsprechenden Methode in actionPerformed in ActionListener).

Die erste Möglichkeit, oben eine Listener-Klasse zu erstellen, kann eine innere Klasse sein, und die zweite Möglichkeit, einen Listener zu erstellen, ist eine anonyme innere Klasse, die leicht zu verstehen ist.

Trennungsdesign von Antwort und Schnittstelle

Wir schreiben Ereignisverarbeitung und Schnittstelle zusammen. Eines ist unpraktisch in der Wartung, und das andere führt dazu, dass die aktuelle Codedatei aufgebläht wird. Daher empfehle ich Ihnen dennoch, die Antwort von Ereignissen zu trennen von der Schnittstelle, was nicht nur die ersten beiden Mängel beheben, sondern auch die Wiederverwendbarkeit des Codes verbessern kann. Ignorieren Sie jedoch nicht die Verwendung innerer Klassen und anonymer innerer Klassen, da jede ihre eigenen Vor- und Nachteile hat und wir diese umfassend berücksichtigen müssen.

Das Swing-Paket bietet einen sehr praktischen Mechanismus zum Kapseln von Befehlen und deren Verbindung mit mehreren Ereignisquellen, nämlich der Aktionsschnittstelle. Eine Aktion ist ein Objekt, das Folgendes umfasst:

• Beschreibung des Befehls (eine Textzeichenfolge und ein optionales Symbol)

• Parameter, die zum Ausführen des Befehls erforderlich sind (z. B. die angeforderte Farbänderung im aufgeführten Beispiel)

Weitere Informationen finden Sie in der API.

Es ist zu beachten, dass Action eine Schnittstelle und keine Klasse ist. Alle Klassen, die diese Schnittstelle implementieren, müssen 7 der Methoden implementieren. Glücklicherweise gibt es eine Klasse, die alle Methoden dieser Schnittstelle implementiert, mit Ausnahme der actionPerformed-Methode, nämlich AbstractAction. Diese Klasse speichert alle Name/Wert-Paare und verwaltet Eigenschaftsänderungs-Listener. Wir können die AbstractAction-Klasse direkt erweitern und die actionPerformed-Methode in der erweiterten Klasse implementieren.

Eine bessere Entwurfsmethode, die ich gesehen habe, ist: Die Listener-Klasse erbt javax.swing.AbstractAction und die Komponente wird bei der Registrierung auf der Komponente an den Listener übergeben.

Listener:

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
	}
}

Ereignisquelle:

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

Erstellen Sie einen Listener, der einen Methodenaufruf enthält.

java.beans.EventHandler ist vom Standpunkt der Benennung aus ein Event-Manager. Die Erklärung der offiziellen API lautet: Die EventHandler-Klasse bietet Unterstützung für die dynamische Generierung von Ereignis-Listenern. Die Methoden dieser Listener führen eine einfache Anweisung aus, die das eingehende Ereignisobjekt und das Zielobjekt umfasst.

Referenz für eine detailliertere Erklärung:————————>>>>>>>>>

Beispiel für die Verwendung von EventHandler:

EventHandler Die einfachste Art der Verwendung Es wird ein Listener installiert, der eine Methode für das Zielobjekt ohne Parameter aufruft. Im folgenden Beispiel wird ein ActionListener erstellt, der die toFront-Methode für eine javax.swing.JFrame-Instanz aufruft.

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

Wenn myButton gedrückt wird, wird die Anweisung „frame.toFront()“ ausgeführt. Durch Definieren einer neuen Implementierung der ActionListener-Schnittstelle und Hinzufügen ihrer Instanz zur Schaltfläche kann der Benutzer den gleichen Effekt mit zusätzlicher Typsicherheit zur Kompilierungszeit erzielen:

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

Die andere einfachste Verwendung von EventHandler erfolgt über die Listener-Schnittstelle ( Extrahiert die Eigenschaft Wert aus dem ersten Parameter der Methode in einem Ereignisobjekt) und verwendet ihn, um den Eigenschaftswert im Zielobjekt festzulegen. Im folgenden Beispiel wird ein ActionListener erstellt, der die nextFocusableComponent-Eigenschaft des Zielobjekts (myButton) auf den Wert der „source“-Eigenschaft des Ereignisses setzt.

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

Dies würde der folgenden inneren Klassenimplementierung entsprechen:

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

Es ist auch möglich, einen EventHandler zu erstellen, der das eingehende Ereignisobjekt einfach an die Zielaktion übergibt. Wenn der vierte Parameter in EventHandler.create eine leere Zeichenfolge ist, wird das Ereignis wie folgt übermittelt:

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

Dies entspricht der folgenden inneren Klassenimplementierung:

//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中文网！

Das obige ist der detaillierte Inhalt vonWelche Verhaltensweisen können Objekte erkennen und auf sie reagieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!