Events

[Guest]

Hallo zusammen,

folgendes Problem.

Ich beschäftige mich zur Zeit mit Events (Java).

Ein kleines Beispiel aus einem Buch, was ich nicht ganz verstehe:

public class ButtonFrame extends JFrame implemenst ActionListener
{
    public void iniUI()
        {
          JButton button = new JButton("OK");
          button.addActionListener(this)
        }
          public void actionPerformed(ActionEvent ae)
            {
            }
}

Im Buch wird dazu folgendes ausgesagt:

Es wird zur Laufzeit mit "button.addActionListener(this)" ein Objekt der Klasse "ButtonFrame" als Ereignisempfänger
beim Objekt "button" registriert. Die Klasse des übergeordneten Objekts muss die Schnittstelle "ActionListener"
implementieren.

1. Ich dachte der Ereignisempfänger ist das Inteface, z.B. ActionListener, das Methoden zur Verarbeitung von
Ereignissen zu Verfügung stellt und diese dann implementiert werden müssten.
Warum reagiert denn die Klasse auf die Ereignisse??

2. Was hat ein Ereignistyp, wie z.B. ActionEvent mit der Schnittstelle ActionListener zu schaffen. Hängen die beiden
irgendwie zusammen?????

3. Kann man die Ereignisbehandlung Analog zu try-catch betrachten?? Wenn im try-Block ein Fehler auftaucht, wird ein Objekt erzeugt, das mit einigen Informationen ausgestatet ist aufgefangen und an den catch-Block zur weiterverarbeitung geleitet ( ob ein oder meherere catch-Blöcke vorliegen ist jetzt nicht wichtig).

Bei der Ereignisbehandlung habe ich mir etwas ähnliches vorgestellt, wie z.B. wenn auf ein Button-Objekt, an dem
einen ActionListener angemeldet ist geklickt wude, wird ein Objekt erzeugt, das Informationen über das Ereignis enthält
und an die Methode "public void actionPerformed(ActionEvent ae), die ein Obejkt vom Typ ActionEvent aufnimmt übergeben
wird und dann innerhalb der Methode, wie bei catch der Block ausgeführt wird.
Aber da kommt dieses "this" ins Spiel, was ich da nicht verstehe :bahnhof:

Ich hoffe, ich konnte mein kleines Problem einigermaßen deutlich erklären, ???:L

danke im voraus, monet

 

[Marco13]

Deine Zusammenfassung am Ende war so richtig, dass ich mich Frage, warum du die Fragen überhaupt gestellt hast ???:L

1. Ich dachte der Ereignisempfänger ist das Inteface, z.B. ActionListener, das Methoden zur Verarbeitung von
Ereignissen zu Verfügung stellt und diese dann implementiert werden müssten.
Warum reagiert denn die Klasse auf die Ereignisse??

Weil sie ein ActionListener IST (durch das "implements ActionListener"). Man kann bei "addActionListener" jedes beliebige Objekt übergeben, solange seine Klasse "implements ActionListener" hat, und damit die Methode "actionPerformed(ActionEvent e)" anbietet. Der Button braucht über das übergebene Objekt NICHTS zu wissen, NUR dass es diese Methode anbietet - und das ist durch das "implements ActionListener" zugesichert.

2. Was hat ein Ereignistyp, wie z.B. ActionEvent mit der Schnittstelle ActionListener zu schaffen. Hängen die beiden
irgendwie zusammen?????
Ja, insofern, dass jede Klasse, die "implements ActionListener" ist, eine Methode "actionPerformed(ActionEvent e)" anbietet.

3. Kann man die Ereignisbehandlung Analog zu try-catch betrachten?? Wenn im try-Block ein Fehler auftaucht, wird ein Objekt erzeugt, das mit einigen Informationen ausgestatet ist aufgefangen und an den catch-Block zur weiterverarbeitung geleitet ( ob ein oder meherere catch-Blöcke vorliegen ist jetzt nicht wichtig).
Nein ... nicht direkt. Aus... theoretischer Sicht könnte man gewisse "Parallelen" sehen, aber sprachlich ist es schon SEHR unterschiedlich.

Etwas (nur wenig) vereinfacht kann man sich die Sache mit den ActionListenern bei einem Button etwa so vorstellen:

class Button
{
    private List<ActionListener> actionListeners = new ArrayList<ActionListener>();

    public void addActionListener(ActionListener a) { actionListeners.add(a); }

    public void ichWurdeAngeklickt()
    {
        ActionEvent event = new ActionEvent("....");
        for (ActionListener actionListener : actionListeners) actionListener.actionPerformed(event);
    }
}

 

[Guest]

Hi,
danke für die schnelle Antwort.

Man kann bei "addActionListener" jedes beliebige Objekt übergeben, solange seine Klasse "implements ActionListener" hat, und damit die Methode "actionPerformed(ActionEvent e)" anbietet

1. Also könnte ich das auch so schreiben: "okbuton.addActionListener(this.okbutton)" ??

Nein ... nicht direkt. Aus... theoretischer Sicht könnte man gewisse "Parallelen" sehen, aber sprachlich ist es schon SEHR unterschiedlich.

2. Sorry, habe mich vielleicht falsch ausgedrückt. Ich meinte nur vom "Prinzip" her Analog zu tray-catch.

Weil sie ein ActionListener IST (durch das "implements ActionListener"). Man kann bei "addActionListener" jedes beliebige Objekt übergeben, solange seine Klasse "implements ActionListener" hat, und damit die Methode "actionPerformed(ActionEvent e)" anbietet. Der Button braucht über das übergebene Objekt NICHTS zu wissen, NUR dass es diese Methode anbietet - und das ist durch das "implements ActionListener" zugesichert.

3. Also, ich habe das so verstanden:
Die "normale" Klasse (z.B. class Auto) wird durch die Implementierung von "implements ActionListener" und die implementierung der notwendigen Methode (hier dann "public void actionPerformed(AcetionEvent ae)
zum "Wächter" eines möglichen Ereignisses, dass z.B. durch einen Button ausgelößt werden kann.

2. Was hat ein Ereignistyp, wie z.B. ActionEvent mit der Schnittstelle ActionListener zu schaffen. Hängen die beiden
irgendwie zusammen?????
Ja, insofern, dass jede Klasse, die "implements ActionListener" ist, eine Methode "actionPerformed(ActionEvent e)" anbietet.

4. Das habe ich leider nicht ganz verstanden, was Du damit meintest. Kannst Du mir vielleicht Quellen sagen, wo ich
das nachschlagen könnte??

Danke, monet

 

[Marco13]

1. Also könnte ich das auch so schreiben: "okbuton.addActionListener(this.okbutton)" ??
Nein. "this.okbutton" ist ja vmtl. ein Objekt vom Typ "JButton". Und JButton hat NICHT das benötigte "implements ActionListener" bzw. die Methode "actionPerformed".


Die "normale" Klasse (z.B. class Auto) wird durch die Implementierung von "implements ActionListener" und die implementierung der notwendigen Methode (hier dann "public void actionPerformed(AcetionEvent ae)
zum "Wächter" eines möglichen Ereignisses, dass z.B. durch einen Button ausgelößt werden kann.

Genau. Als Beispiel:

class Foo implements ActionListener
{
    // Compilerfehler: Die Methode "actionPerformed" fehlt
}

// Läßt sich compileren - aber man sieht von außen nicht, 
// dass die methode "actionPerformed" vorhanden ist,
// weil das "implements ActionListener" fehlt. D.h. man
// kann Objekte dieser Klasse NICHT als ActionListener
// verwenden
class Bar 
{
     public void actionPerformed(ActionEvent e) { ... } 
}

// Funktioniert: Jeder sieht, dass das ein ActionListener 
// ist (wegen "implements") und damit die Methode 
// "actionPerformed" anbieten muss
class FooBar implements ActionListener
{
     public void actionPerformed(ActionEvent e) { ... } 
}

...
    // someButton.addActionListener(new Foo()); // Hinfällig, wegen Compilerfehler oben
    //someButton.addActionListener(new Bar()); // Geht nicht: Man "weiß nicht", dass Bar die Methode actionPerformed hat
    someButton.addActionListener(new FooBar()); // Geht: FooBar ist ein ActionListener und hat die actionPerformed-Methode

4. Das habe ich leider nicht ganz verstanden, was Du damit meintest. Kannst Du mir vielleicht Quellen sagen, wo ich
das nachschlagen könnte??

Hm :? bei irgendwelchen Fragen zu Swing muss man eigentlich nur
"How to" XXX
in eine Suchmaschine eintippen, und landet bei
"How to" ActionListener
sofort auf http://java.sun.com/docs/books/tutorial/uiswing/events/actionlistener.html ....

 

[Guest]

1. Also könnte ich das auch so schreiben: "okbuton.addActionListener(this.okbutton)" ??
Nein. "this.okbutton" ist ja vmtl. ein Objekt vom Typ "JButton". Und JButton hat NICHT das benötigte "implements ActionListener" bzw. die Methode "actionPerformed".

Ach so, nur ein Objekt vom Typ einer Klasse,die das passende ActionListener-Interface implementiert wird mit
dem Typ des Objekts "verbunden", dass das Ereignis ausglöst hat.

Dein Beispiel ist echt gut

class Foo implements ActionListener
{
    // Compilerfehler: Die Methode "actionPerformed" fehlt
}

// Läßt sich compileren - aber man sieht von außen nicht,
// dass die methode "actionPerformed" vorhanden ist,
// weil das "implements ActionListener" fehlt. D.h. man
// kann Objekte dieser Klasse NICHT als ActionListener
// verwenden
class Bar
{
     public void actionPerformed(ActionEvent e) { ... }
}

// Funktioniert: Jeder sieht, dass das ein ActionListener
// ist (wegen "implements") und damit die Methode
// "actionPerformed" anbieten muss
class FooBar implements ActionListener
{
     public void actionPerformed(ActionEvent e) { ... }
}

...
    // someButton.addActionListener(new Foo()); // Hinfällig, wegen Compilerfehler oben
    //someButton.addActionListener(new Bar()); // Geht nicht: Man "weiß nicht", dass Bar die Methode actionPerformed hat
    someButton.addActionListener(new FooBar()); // Geht: FooBar ist ein ActionListener und hat die actionPerformed-Methode

Ich glaube, jetzt ist der Cent gefallen. Wenn eine Klasse ein Interface implementiert,dann kann ein Objekt der Klasse auf Methoden des Interface zugreifen bzw. die Klasse muss alle Methoden des Interface implementieren, da diese abstrakt sind.
1. Wenn jetzt die Button-Instanz ein Ereignis auslöst, wird ein Objekt vom Typ der Klasse, z.B. Auto oder wie in deinem Beispiel "new FooBar()" erzeugt und mit Informationen über den Ereignistyp der Methode "public void actionPerformed(ActionEvent ae)" übergeben, da diese ja als Argument so einen Typ erwartet.
Ist es bis hier richtig??
Mir ist noch nicht ganz klar, was dann passiert und wo "ActionEvent" ins Spiel kommt????


Wenn ich das jetzt richtig verstanden habe, dann könnte ich die Zeile 28 auch so schreiben??

class Auto implements ActionListener{

........ okbutton.addActionListener(opel);// Instanz der Klasse Auto


Auto opel = new Auto()
}

danke, monet

 

[Marco13]

Ich glaube, jetzt ist der Cent gefallen. Wenn eine Klasse ein Interface implementiert,dann kann ein Objekt der Klasse auf Methoden des Interface zugreifen bzw. die Klasse muss alle Methoden des Interface implementieren, da diese abstrakt sind.
Ja.


1. Wenn jetzt die Button-Instanz ein Ereignis auslöst, wird ein Objekt vom Typ der Klasse, z.B. Auto oder wie in deinem Beispiel "new FooBar()" erzeugt und mit Informationen über den Ereignistyp der Methode "public void actionPerformed(ActionEvent ae)" übergeben, da diese ja als Argument so einen Typ erwartet.
Ist es bis hier richtig??

Nein, nicht so ganz. Das, was dort bei addActionListener übergeben wird, ist nur der Listener - d.h. der wird i.a. nicht bei jedem Event neu erzeugt. Er wird EINmal registriert, und bekommt dann bei jedem Klick ein ActionEvent-Objekt an seine actionPerformed-Methode übergeben.


Mir ist noch nicht ganz klar, was dann passiert und wo "ActionEvent" ins Spiel kommt????


Schau nochmal die Button-Klasse aus meiner ersten Antwort an: Dort wird bei addActionListener irgendein ActionListener übergeben (entweder ein "new FooBar()", oder ein 'opel', aus deinem letzen Beispiel). Der wird gespeichert. Sobald der Button geklickt wurde, wird ein ActionEvent erstellt. Dieser ActionEvent wird ALLEN registrierten ActionListenern übergeben, indem für jeden ActionListener die Methode "actionListener.actionPerformed(event);" aufgerufen wird (die er ja anbieten MUSS, weil er ja ein ActionListener ist).



Wenn ich das jetzt richtig verstanden habe, dann könnte ich die Zeile 28 auch so schreiben??
[... code ...]


Ja, das stimmt so auch.


Nochmal einen Schritt zurück: Die ganze Sache mit den Interfaces und Listenern dient dem Zweck, eine gewisse Flexibilität zu schaffen. Man hat einen Button, und übergibt dem bei "addActionListener" irgendeinen ActionListener. WAS das genau für ein Objekt ist, weiß man nicht, aber man weiß eins: Es ist ein ActionListener, und es bietet demnach eine Methode "actionPerformed" an. Der Zusatz "...implements ActionListener" ist sozusagen das "Versprechen", dass es diese Methode gibt.

Die Alternative wäre ja irgendwas überspezialisiertes:

class MeineGanzSpezielleKlasseFürDenOKButton
{
    void derOKButtonWurdeGeklickt() { .... }
}

class MeinOKButton
{
    private MeineGanzSpezielleKlasseFürDenOKButton meinGanzSpeziellesObjektFürDenOKButton;

    void legeFestWasBeiEinemKlickGemachtWerdenSoll(MeineGanzSpezielleKlasseFürDenOKButton x)
    {
        meinGanzSpeziellesObjektFürDenOKButton= x;
    }

    public void ichWurdeAngeklickt()
    {
        meinGanzSpeziellesObjektFürDenOKButton.derOKButtonWurdeGeklickt();
    } 
}

Mit Hilfe des allgemeinen, abstrakten Listener-Konzepts hat man "irgendeinen" Button, und der kann "irgendwelche" ActionListener haben. Man kann z.B. an einen Button auch mehrere ActionListener hängen, die alle unterschiedliche Sachen machen. Man kann auch ein und denselben ActionListener an mehrere Buttons hängen. Und wenn man später feststellt, dass beim Klick auf den OK-Button irgendwas anderes gemacht wurde, muss man am Button selbst nichts ändern. Man muss nur einen anderen ActionListener dranhängen.

 

[Guest]

Hi,

danke erstmal für deine Mühe :toll:

....Dort wird bei addActionListener irgendein ActionListener übergeben (entweder ein "new FooBar()", oder ein 'opel', aus deinem letzen Beispiel). Der wird gespeichert. Sobald der Button geklickt wurde, wird ein ActionEvent erstellt.....

Wird das Objekt "opel" dann in der Klasse ActionEvent gespeichert oder geht es noch höher in die Klasse EventObjekt??? Wenn ja, dann stelle ich mir das so vor, dass das übergebene Objekt "opel", welches sich in okbutton.addActionListener(opel)" befindet an die Klasse ActionEvent übergeben und dort gespeichert wird.
Wenn nun der Button "okbutton" angeklickt wird, wird ein Objekt vom Typ ActionEvent an die Methode "public void
actionPerformed(ActionEvent ae)" übergeben :shock: und dann wird die Methode bzw. der Block ausgeführt.
Ich hoffe das stimmt so :roll:

1. Wenn jetzt die Button-Instanz ein Ereignis auslöst, wird ein Objekt vom Typ der Klasse, z.B. Auto oder wie in deinem Beispiel "new FooBar()" erzeugt und mit Informationen über den Ereignistyp der Methode "public void actionPerformed(ActionEvent ae)" übergeben, da diese ja als Argument so einen Typ erwartet.
Ist es bis hier richtig??

Nein, nicht so ganz. Das, was dort bei addActionListener übergeben wird, ist nur der Listener - d.h. der wird i.a. nicht bei jedem Event neu erzeugt. Er wird EINmal registriert, und bekommt dann bei jedem Klick ein ActionEvent-Objekt an seine actionPerformed-Methode übergeben.

Mit "Nein, nicht so ganz", meinst Du damit, dass es nicht an die Methode "public void
dirket übergeben, sondern an die Klasse "ActionEvent". :?, die ein Objekt vom Typ ihrer Klasse an die Methode übergibt!?!?!

Ich glaube, ich sehe den Wald vor lauter Bäumen nicht :autsch:

Danke, monet

 

[Marco13]

Nein, der ActionListener wird nicht im Event gespeichert. Dort, wo der Event erstellt wird, ist das genaue Objekt ja nicht bekannt (nur als ActionListener). Und im ActionListener selbst würde es einem nichts bringen, wenn man "sich selbst" aus dem Event rausholen könnte... Kannst auch mal http://www.galileocomputing.de/open...15_005.htm#mj7dcc39792edc89b6ee4cc990f869de5c oder ähnliche Seiten dazu lesen.

 

[Gast]

Alles klar,

danke nochmals. Jetzt habe ich schon mal einen guten Ansatz!!!!

Gruß monet