# Verständnis Problem Java-Listener.



## Javaman91 (2. Mrz 2016)

Hallo Leute,

ich versuche mit Hilfe eines Java Tutorials zu Verstehen, was der Java-Listener ist.
Doch leider blicke ich da nicht durch.

Es gibt ja zwei Listener:

1. Action-Listener
2. Event-Listener

Den Action-Listener verwende ich z.B. wenn ein Button gedrückt wird, dann soll etwas passieren.

Wann verwende ich den Event-Listener?


----------



## Joose (2. Mrz 2016)

Ein ActionListener ist nichts anderes als ein EventListener (... er reagiert auf das ActionEvent).
EventListener ist die allgemeine Beschreibung der Listener in Java (Swing) ... der ActionListener ist da schon ein spezifischer.


----------



## Javaman91 (2. Mrz 2016)

Das heißt, das EventListener der Überbegriff für alle in Java vorkommenden Listener ist.
Der Action Listener ist einer von vielen.


----------



## Joose (2. Mrz 2016)

Es gibt ein Interface das heißt "EventListener" (https://docs.oracle.com/javase/7/docs/api/java/util/EventListener.html)
Von diesem Interface erben (wie man in der Doku sehen kann) eigentlich alle anderen Listener. 
ActionListener selbst ist auch nur ein Interface, welches von EventListener erbt. (https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionListener.html)


----------



## Javaman91 (2. Mrz 2016)

O.K.,

also der EventListener ist ein Interface. Er ist quasi die höchste Instanz.
Von ihm werden alle anderen Listener abgeleitet (wie z.B. der ActionListener).

Hab ich es nun richtig erklärt?


----------



## Joose (2. Mrz 2016)

Ja


----------



## Javaman91 (2. Mrz 2016)

Super Danke!

Nun wollte ich in meinem Programm den Button mit ActionListener was anzeigen lassen.
Doch ich verstehe nicht, was ich alles dafür ins Programm schreiben muss damit das funktioniert?


----------



## Joose (2. Mrz 2016)

Hier 2 Seiten mit Beispielen: 
https://docs.oracle.com/javase/tutorial/uiswing/events/actionlistener.html
http://www.java-tutorial.org/actionlistener.html


----------



## Javaman91 (10. Mrz 2016)

Ich habe mich mit dem Sourcecode von :"http://www.java-tutorial.org/actionlistener.html" auseinander gesetzt.

Ich habe das so Verstanden:

Mit "public class BeispielListener extends JFrame" erzeugt er eine neue Klasse, die von JFrame abgeleitet wird. Das bedeutet, das Objekte die von der Klasse "BeispielListener" erzeugt werden ein JFrame sind.

Erzeugt wird das Objekt mit folgendem Sourcecode:

```
public static void main(String[] args)
    {
        // Ein neues Objekt der Klasse BeispielListener wird erzeugt
        // und sichtbar gemacht
        BeispielListener bl = new BeispielListener();
        bl.setVisible(true);
    }
```
Die void main Methode ist die Methode, die beim Programmstart als erstes aufgerufen wird.
Hier wird dann das Objekt "bl" anhand der Klasse "BeispielListener" erzeugt.

Da ja die Klasse "BeispielListener" von der Klasse "JFrame" abgeleitet wird (mit dem Schlüsselwort "extends"), handelt es sich beim Objekt "bl" um ein JFrame Fenster.

Mit der Methode:"public BeispielListener()" wird nun festgelegt, dass das bl Objekt, das ja ein JFrame Fenster ist 3 Buttons bekommt:


```
button1 = new JButton("Button 1");
button2 = new JButton ("Button 2");
button3 = new JButton ("Button 3");
```

+ ein Panel und ein Label.

Mit dem schlüsselwort: "this" wird einfach gesagt, dass es um das "bl" Objekt geht:

Beispiel:


```
this.setTitle("ActionListener Beispiel");
this.setSize(400, 200);
```

sagt einfach nur, dass das "bl" Objekt die Bezeichnung "ActionListener Beispiel" bekommt und die größe 400*200 Pixel beträgt.

Das heißt, wenn das Schlüsselwort "this" verwendet wird, dann geht es in diesem Beispiel immer um das  "bl" Objekt.

genauso auch hier:


```
this.add(panel);
```

hier wird dem "bl" Objekt ein JPanel hinzugefügt.


Habe ich das bis hierhin so richtig Verstanden?


Mfg & DANKE für die Hilfe!


----------



## Joose (10. Mrz 2016)

Ja klingt richtig.

Hinweis: Du kannst Code mittels Code-Tags in deinem Beitrag formatieren
[java] ... dein code ...[/java]


----------



## Javaman91 (11. Mrz 2016)

Dann verstehe ich nicht, warum er eine eigene BeispielListener Methode erstellt,

```
public BeispielListener()
```

um drei Button usw. zu erzeugen?

Wieso macht er dies nicht einfach in der main Methode?

MfG und Danke für den Hinweis?


----------



## kneitzel (11. Mrz 2016)

Das liegt einfach nur an der schlechten Namensgebung und der Vermengung von Dingen.

```
public class BeispielListener extends JFrame implements ActionListener
```

Die erstellte Klasse BeispielListener ist zum einen ein erweitertes JFrame. Also ist es ein Fenster und das Fenster soll halt paar Controls enthalten.
Die Klasse implementiert aber auch das Interface ActionListener. Somit ist es nicht nur ein erweitertes JFrame sondern auch noch zusätzlich ein ActionListener.

Davon darf man sich nicht irritieren lassen. Man könnte den Code aufteilen. Dann hat man auf der einen Seite nur das Fenster und in einer separaten Klasse den Listener. Zugriff auf das Fenster könnte man ja über den Konstruktor vom Listener, der eine Fenster-Referenz bekommen, übergeben.

Aber da kommen wir dann schnell in eine Design-Diskussion, bei der man dann auch überlegen müsste, in wie weit ein ableiten von JFrame überhaupt notwendig ist. Statt dessen kann man einfach ein JFrame als Instanzvariable führen und dann damit arbeiten. Es muss also nicht von JFrame abgeleitet werden.
Aber das ist dann wieder ein etwas anderes Thema.


----------



## Javaman91 (11. Mrz 2016)

Das heißt wenn ich den Action Listener nicht mit der Klasse BeispielListener implementieren würde, dann bräuchte ich die Methode:

```
public BeispielListener()
```
nicht.

Ist das so korrekt?


----------



## kneitzel (11. Mrz 2016)

Diese Methode ist der Konstruktor. Den brauchst Du, wenn bei der Erstellung einer Instanz etwas initialisiert werden muss.


----------



## Blender3D (12. Mrz 2016)

Der ActionListerner ist eine Schnittstellenvereinbarung. Die Klasse JButton besitzt eine Methode. addActionListener( ActionListener listener );
Das bedeutet wenn Du irgend eine Klasse erstellst, die das Interface ActionListener implementiert und dann bei einem JButton die Methode addActionLister( deineKlasse ) aufrufst. Dann ruft der JButton, sofern auf ihn geklickt wird, die Methode deineKlasse.actionPerformed( ActionEvent event ) auf. Ihn dieser Methode Deiner Klasse, kannst Du dann mit Deinem Code auf das Klicken des Buttons reagieren.


----------



## Javaman91 (12. Mrz 2016)

Jetz habe ich es Verstanden.


```
public BeispielListener()
```

Damit wird der Konstruktor der Klasse erzeugt.
Dabei muss er den gleichen Namen tragen wie die Klasse also "BeispielListener".


Wenn ich nun ein Objekt der Klasse "BeispielListener" erzeugen will, dann muss ich das mit dem Schlüsselwort "new" machen. Dabei rufe ich dann den gerade erwähnten Konstruktor der Klasse auf und erzeuge ein Objekt.

Beispiel:

Ich habe ein Programm wo ich einen Button erzeugen möchte, dann würde der Code so aussehen:


```
JButton Exit = new JButton();
```

Das heißt "JButton" ist die Klasse. "Exit" der Name des neuen Buttons-Objekt.
"new" ruft mir nun den Konstruktor der Klasse auf, um anhand der JButton Klasse ein Objekt zu erzeugen.

Hab ich das so richtig Verstanden?


----------



## kneitzel (12. Mrz 2016)

Ja das hört sich gut an. Maximal ein paar kleine Feinheiten im Ausdruck fallen mir jetzt auf, die aber beim Verständnis keine wirkliche Rolle spielen. So rufst Du den Konstruktor nicht auf, sondern das wird vom System beim new Operator gemacht.


----------



## Javaman91 (13. Mrz 2016)

Mit dem Befehl:


```
button1.addActionListener(this);
```

füge ich dem Button den ActionListener hinzu.

Der ActionListener überwacht nun den Button.
Wird der Button gedrückt, dann erkennt das der ActionListener und ruf die ActionPerformed-Methode auf:


```
public void actionPerformed (ActionEvent ae)
```

In der ActionPerformed-Methode wir dann abgefragt, welcher Button gedrückt wurde.


----------



## Joose (14. Mrz 2016)

Javaman91 hat gesagt.:


> füge ich dem Button den ActionListener hinzu.


Ja



Javaman91 hat gesagt.:


> Wird der Button gedrückt, dann erkennt das der ActionListener und ruf die ActionPerformed-Methode auf:


Auch richtig. 
Ergänzend dazu: Du kannst einen(!) Button auch 10 verschiedene ActionListener anhängen. Sobald der Button gedrückt wird werden von diesen 10 Listener der Reihe nach die "actionPerformed" Methode aufgerufen.



Javaman91 hat gesagt.:


> In der ActionPerformed-Methode wir dann abgefragt, welcher Button gedrückt wurde.


Achtung: Man kann ein und denselben ActionListener für unterschiedliche Buttons verwenden. Das passiert häufig in Beispielen und ist in kleinen Anwendungen sicher auch schneller und unkomplizierter.
Aber es spricht auch nichts dagegen für jeden Button einen eigenen Listener zu schreiben. Dadurch spart man sich die Abfrage welcher Button gedrückt wurde.


----------



## Javaman91 (14. Mrz 2016)

Warum muss ich in der ActionPerformed-Methode dann mit getSource() abfragen?

Was bedeutet getSource(), ist das eine Methode die aufgerufen wird?


----------



## beatles (14. Mrz 2016)

bin kein Experte aber damit wird abgefragt welcher button gedrückt wurde z.B.
...
_int whichButton = buttons.indexOf(click.getSource());_//welcher Button wurde gedrückt


----------



## Joose (15. Mrz 2016)

Javaman91 hat gesagt.:


> Warum muss ich in der ActionPerformed-Methode dann mit getSource() abfragen?


Du musst ja nicht. "getSource" kann man dann verwenden wenn es wichtig ist zu prüfen welche Komponente gedrückt/geklickt wurde.



Javaman91 hat gesagt.:


> Was bedeutet getSource(), ist das eine Methode die aufgerufen wird?


Ja sobald auf etwas "()" folgen kann man eigentlich davon ausgehen das hier eine Methode aufgerufen wird -> Grundlagen OOP
Wenn du genauer wissen willst wozu eine Methode gut ist was sie machen sollte und welchen Wert sie dir zurückliefert dann nutze die Java Dokumentation
https://docs.oracle.com/javase/7/docs/api/java/util/EventObject.html#getSource()


----------



## Javaman91 (15. Mrz 2016)

Jetzt habe ich das auch verstanden.

Wie bereits erwähnt ruft der ActionListener die ActionPerformed-Methode auf und übergibt Ihr einen Parameter: "ActionEvent".

Nun kann in der ActionPerformed-Methode mit dem Code:


```
ActionEvent.getSource()
```

der jeweilige Button abgefragt werden und dann eine bestimmte handlung ausgeführt werden.

PS: ActionEvent besitzt im Code normalerweise eine Bezeichnung wie z.B. "e".

Somit lautet der Code z.B.: 
	
	
	
	





```
e.getSource()
```
.


Müsste eigentlich passen oder?


----------



## Joose (15. Mrz 2016)

Genau


----------



## Javaman91 (15. Mrz 2016)

Dann verwirrt mich folgendes.

Ich habe ja bereits erwähnt, dass das Schlüsselwort: "this" eine referenz auf das aktuelle Objekt macht.

Wenn ich aber foldengen code anschaue:


```
button.addActionListener(this);
```

dann macht das "this" hier keine referenz auf ein Objekt sondern auf den konstruktor der Klasse.


----------



## mrBrown (15. Mrz 2016)

Javaman91 hat gesagt.:


> dann macht das "this" hier keine referenz auf ein Objekt sondern auf den konstruktor der Klasse.



Das ist auch an der Stelle die Referenz auf das aktuelle Objekt, warum sollte das Plötzlich eine Referenz auf den Konstruktor sein?


----------



## Javaman91 (15. Mrz 2016)

Laut dieser Webseite ist es ein Verweis auf den Konstruktor:

http://javabeginners.de/Ereignisbehandlung/Buttonereignisse.php


----------



## Joose (15. Mrz 2016)

Stimmt steht zwar so dort, ist aber falsch 
"this" verweist immer nur auf das aktuelle Objekt. Selbst wenn du im Konstruktor "this" verwendest, verweist du auf das aktuelle Objekt was eben gerade initialisiert wird.


----------



## Javaman91 (15. Mrz 2016)

Mir stellt sich trotzdem die Frage, warum ich immer "this" verwende.

Ich kann doch gleich:


```
bl.setTitle("ActionListener Beispiel");
```

statt


```
this.setTitle("ActionListener Beispiel");
```

verwenden.

Hat das vielleicht den Hintergrund, dass ich mir einen haufen arbeit ersparen kann, wenn ich z.B. den Namen des Objektes von "bl" auf "el" ändere?

Wenn ich statt "this" z.B. immer "bl" verwende, dann müsste ich alle "bl" durch "el" ersetzen.
Da sich "this" aber immer auf das aktuelle Objekt bezieht, ist es egal wie das Objekt heißt.
Somit habe ich mir einen menge Schreibarbeit erspart.

So hab ich das Verstanden?

MfG und DANKE für die Hilfe!


----------



## Joose (15. Mrz 2016)

Beispiel:

```
private String data;

public void setData(String data) {
    this.data = data; // data = data; würde hier nicht funktionieren
}
```

"this" wird meist dann verwendet ein Namensproblem zwischen Parametern,lokalen Variablen und Instanzattributen zu "lösen".
Bei dem Beispiel oben hat die Klasse ein Attribut "data". "setData" soll der Instanzvariable "data" einen Wert zuweisen, sprich wird brauchen einen Parameter. Damit wir uns hier nicht einen neuen Namen ausdenken müssen nennen wir diesen ebenfalls "data".
Wenn du "data = data" schreiben würdest, dann wird dem Parameter der Parameter zugewiesen, was aber nicht dein Ziel ist.
Mit "this" greifst du nun auf das aktuelle Objekt und dessen Methoden und Attribute zu.


----------



## Javaman91 (16. Mrz 2016)

Also:


```
privat String data;
```

ist eine globale Variable.


```
public void setData(String data)
```

hier ist "(String data)" die Methoden-Variable.

Mit "this" sage ich einfach, dass es sich beim "this.data" um die globale Variable des Objektes handelt, also um:


```
private String data;
```

Ganz einfach gesagt, sorgt das "this" hier einfach für eine unterscheidung der beiden gleich genannten
"data" Variablen. Damit das Programm weiß, welches "data" zu welcher Variable gehört.


----------



## Joose (16. Mrz 2016)

"globale Variable" ist der falsche Ausdruck, ich muss zugeben ich habe auch wenig Code dazu geschrieben.
Stell dir meinen Beispiel Code einfach innerhalb einer Klasse vor. Damit wäre "data" eine Instanzvariable.
Ansonsten stimmts, "this" wird hierbei nur zur Unterscheidung verwendet.


----------



## kneitzel (17. Mrz 2016)

Evtl. liegt dein Verständnisproblem darin, dass this oft weggelassen werden kann.

Wenn Du in einer Klasse z.B. eine Instanzvariabel button hast, dann kannst Du innerhalb einer Funktion schreiben:
button.setText("aaaaa");

Aber das ist streng genommen ein
this.button.setText("aaaaa");

Das this können wir nur weglassen, wenn es in der Funktion keine lokale Variable / Parameter button gibt. Der Compiler "sucht" halt nach einem button, wenn der Ort nicht genau angegeben wurde.


----------



## Javaman91 (17. Mrz 2016)

Ich könnte den Code auch so schreiben, dann bräuchte ich kein "this":


```
private String data;

public void setData(String data1) {
    data = data1;  
}
```

Nur als Beispiel.


----------



## Javaman91 (18. Mrz 2016)

Müsste so ja auch funktionieren, oder?


----------



## Jardcore (18. Mrz 2016)

Ja kannst du machen, dann fragt man sich aber wieso die 1  gibt es auch 2 

```
public void setData(String data) {
    this.data = data;
}
```
Ist sauberer.

_this._ verwendet man größtenteils nur in Settern und im Konstruktor.
Aber man kann sich auch dafür entscheiden _this._ überall dort zu benutzten wo du auf Instanzattribute zugreifst. Kommt auf die Firma / Prof. / Leher / Geschmack an.


----------



## Javaman91 (22. Mrz 2016)

Hallo nochmals, aber leider muss ich euch noch was wegen dem Listener fragen.

Laut dieser Seite: "http://www.java-tutorial.org/event-handling.html"

wird beim Betätigen des Buttons ein Objekt der Klasse: "ActionEvent" erzeugt.

Ich habe ja bereits geschrieben, dass der ActionListener einen Button überwacht.
Wenn der Button gedrückt wird, dann bekommt das der ActionListener mit und ruft die ActionPerformed - Methode auf. Weiters übergibt er der Methode einen Parameter, das so genannte ActionEvent.

Das ActionEvent ist doch eine Methodenvariable und keine Klasse von der ein Objekt erzeugt wird??

Jetzt bin ich wieder durcheinander.

Sorry, für die vielen Fragen.


----------



## Joose (22. Mrz 2016)

Nicht ganz richtig, der ActionListener ist nicht derjenige der den Buttonklick registriert. Er wird nur über den Klick informiert indem seine "actionPerformed" Methode aufgerufen wird. Als Parameter wird ein ActionEvent Objekt übergeben.

ActionEvent ist eine Klasse, von dieser Klasse können Objekte erstellt werden. An die "actionPerformed" Methode wird ein Objekt dieser Klasse übergeben.
Du kannst in der actionPerformed Methoden dann über den Parameternamen auf diese Objekt zugreifen.

Zusammen gefasst: Wenn du einem Button keinen ActionListener anhängst, dann wird passiert nichts. Der Klick auf den Button wird aber vom Java Framework trotzdem registriert. Da aber eben keine ActionListener verfügbar sind wird nichts passieren.
Der SourceCode von JButton würde dir hier etwas weiterhelfen:
addActionListener: http://grepcode.com/file/repository...ActionListener(java.awt.event.ActionListener) 
Hier wird der Listener an eine Liste gehängt

fireActionPerformed: http://grepcode.com/file/repository...reActionPerformed(java.awt.event.ActionEvent)
Hier durchläuft eine Schleife diese Listener List und ruft deren "actionPerformed" Methode auf.


----------



## Javaman91 (23. Mrz 2016)

Wenn der ActionListener nicht der jenige ist der die ActionPerformed-Methode aufruft, was macht er dann??


----------



## Joose (23. Mrz 2016)

Der ActionListener wird über eine Action informiert indem die "actionPerformed" Methode des Listeners aufgerufen wird.


----------



## mrBrown (23. Mrz 2016)

Javaman91 hat gesagt.:


> Wenn der ActionListener nicht der jenige ist der die ActionPerformed-Methode aufruft, was macht er dann??



Die ActionPerformed-Methode enthalten, ActionListener ist nur ein Interface, mehr als Methoden enthalten geht gar nicht.


----------



## Javaman91 (23. Mrz 2016)

Ja, aber was ist jetzt die Aufgabe des ActionListeners?


----------



## mrBrown (23. Mrz 2016)

Javaman91 hat gesagt.:


> Ja, aber was ist jetzt die Aufgabe des ActionListeners?


Die actionPerformed() bereitzustellen, die dann vom Button ua aufgerufen wird, um auf das Event zu reagieren.


----------



## kneitzel (23. Mrz 2016)

ActionListener ist nur ein Interface. Dieses Interface besagt, dass eine Klasse, die dieses Interface implementiert, eine actionPerformed(Action Event) Funktion haben muss.
https://docs.oracle.com/javase/7/docs/api/java/awt/event/ActionListener.html

Und wenn man sich nun die Links von Joose ansieht, dann sieht man die wichtigen Funktionen:
- Bei dem Hinzufügen eines ActionListeners wird das übergebene Objekt einfach mit gespeichert.
- Wenn nun das "Event ausgelöst" werden soll, dann kann man einfach alle gespeicherten ActionListener durchgehen und genau diese Funktion aufrufen.

Das ist also im Prinzip nichts anderes als bei allen objekt orientierten Entwicklungen.
Wenn Du eine Klasse Etwas hast, die die Funktion tuEtwas implementiert, dann kannst Du ja Code schreiben wie:

```
Etwas etwas = new Etwas(); // So es so einen Konstruktor gibt.
etwas.tuEtwas();
```

Also Instanz erzeugen und dann eine Funktion aufrufen.

Das ganze geht auch in Funktionen:

```
public void tuEtwasMitParameter(Etwas etwas) {
  etwas.tuEtwas();
}
```

Macht nicht ganz so viel Sinn, aber vor und nach dem Aufruf könnten ja noch andere Befehle stehen. Nur um das ganze zu begreifen.

Statt aber nun auf einer Instanz direkt zu arbeiten, kann man das ja auch trennen. Ich kann innerhalb einer Klasse ja etwas haben wie:

```
public class Demo {
  private Etwas etwas;

  public void setEtwas(Etwas etwas) {
    this.etwas = etwas;
  }

  public void machEtwas() {
    etwas.tuEtwas();
  }
}
```

Und statt die Instanz von Etwas direkt zu speichern, ist es jetzt nur noch ein kleiner Schritt, hier eine Liste von Etwas zu speichern.

Das Nächste, das evtl. verwirren könnte, wäre dann der unsichtbare Aufruf. Bei so GUIs sieht man nicht, was da im Hintergrund passiert. Man hat bei GUI Applikationen meist eine main Funktion, die einfach ein Fenster erzeugt und sich dann beendet. Und komischer Weise läuft die Applikation dann auf magische Art und Weise weiter.
Hier ist wichtig, dass die Hintergründe verstanden werden. Die Java Applikation läuft weiter, solange es Threads gibt, die nicht als Hintergrundthread (daemon) gekennzeichnet sind (bzw. exit aufgerufen wurde). Dieser Thread bearbeitet in der Regel Nachrichten, die vom System kommen (Message Loop). Das Betriebssystem ist also verantwortlich für Maus, Tastatur, Oberfläche, ... und schickt dann den Fenstern Nachrichten. Diese Nachrichten können vielfältig sein. Einfache Dinge wie "zeichne dich neu" (weil das Fenster z.B. verdeckt war) oder "Maus wurde geklickt" bis hin zu komplizierteren Dingen, die wir jetzt einfach mal ignorieren.
Wenn ein Fenster so eine Nachricht bekommt, dann wird es die Nachricht auswerten. Bei einem Mausklick kann es sein, dass es dann erst einmal schaut, auf was geklickt wurde (z.B. ein Button) und dann wird der Button aufgefordert, das Event zu bearbeiten.
Und da kommt dann das Verhalten des Buttons ins Spiel: Wenn der Button so einen Click bearbeiten soll, dann geht er einfach alle Listener durch und ruft auf diesen diese actionPerformed Funktion auf.

Das wäre dann einmal eine ganz ausführliche Erläuterung - auch wenn ich dabei einiges stark vereinfacht habe.


----------



## Blender3D (23. Mrz 2016)

Javaman91 hat gesagt.:


> Wenn der ActionListener nicht der jenige ist der die ActionPerformed-Methode aufruft, was macht er dann??


ActionListener: auf Deutsch Aktion Zuhörer. Also *er wartet auf Aktionen bestimmter Objekte*.
JButton b = new JButton( "Meine Aktion" );
b.addActionListener( myActionListener );
Also die Klasse myActionListerner wartet jetzt auf Aktionen des Buttons b.


----------



## kneitzel (23. Mrz 2016)

Blender3D hat gesagt.:


> b.addActionListener( myActionListener );
> Also die Klasse myActionListerner wartet jetzt auf Aktionen des Buttons b.



Nur eine kleine Verbesserung: Die *Instanz *myActionListener wartet jetzt auf Aktionen des Buttons b.

(Hast Du bestimmt auch so gemeint denke ich mal und Dich nur verschrieben)


----------



## Blender3D (24. Mrz 2016)

kneitzel hat gesagt.:


> Die *Instanz *myActionListener wartet jetzt auf Aktionen des Buttons b.


Stimmt absolut.


----------



## Javaman91 (24. Mrz 2016)

Also ich fasse zusammen:

Ein Event ist ein Ereignis, das z.B. durch einen Button (Button = Eventquelle) ausgelöst wird.
Wenn jetzt z.B. ein Button gedrückt wird, dann wird ein Event ausgelöst. Gleichzeitig wird ein "EventObjekt" der jeweiligen Klasse (z.B. ActionEvent) erzeugt.
Jedes "EventObjekt" besitzt eine Referenz zur Quelle des Auslöser, diese Quelle kann mit der Methode "getSource()" abgefragt werden.

Wichtig ist dabei zu Wissen, das jeder "EventKlasse" auch ein Listener zugeordnet ist.
Bei der "ActionEvent" -Klasse ist es eben der ActionListener.

Ist nun eine Klasse an einem bestimmten Event interessiert, so muss Sie das passende Interface für das jeweilige Event implementieren.

Der Action Listener ist ja nur ein Interface. Ein Interface ist eine spezielle Form einer Klasse.
Ein Interface besitzt nur Methoden und Konstanten, aber keine Konstruktoren.
Deshalb können von einem Interface auch keine Objekte erzeugt werden.
Der ActionListener hat nun die Aufgabe, das Event abzuhören und die "ActionPerformed()" -Methode bereit zu stellen. 

Wenn jetzt ein Button gedrückt wird, dann ruft dieser nicht den ActionListener auf, sondern die Methode des ActionListeners also die "ActionPerformed()"-Methode. In der "ActionPerformed()"-Methode kann nun auf das Ereignis reagiert werden und eine bestimmte Handlung im Programm durchgeführt werden.
Wichtig ist dabei, das der Button beim ActionListener angemeldet wird und zwar mit der Methode "addActionListener".

Hab ich das nun Richtig erklärt??


----------



## Joose (24. Mrz 2016)

Javaman91 hat gesagt.:


> Wichtig ist dabei, das der Button beim ActionListener angemeldet wird und zwar mit der Methode "addActionListener".


Umgekehrt. Du registrierst den ActionListener beim Button


----------



## kneitzel (24. Mrz 2016)

Ja im Groben und Ganzen schon. Nur ganz am Ende hast Du es verdreht:
Wichtig ist dabei, dass der ActionListener (bzw. die Instanz, die dieses Interface implementiert) beim Button angemeldet wird und zwar mit der Methode addActionListener.

Du rufst die Methode ja auf der Button Instanz auf.
Also wenn du hast:
Button b1;
ActionListener al;
machst du:
b1.addActionListener(al);


----------



## Javaman91 (24. Mrz 2016)

Das einzige was ich nicht ganz Verstehe ist, das der ActionListener das ActionEvent abhört??
Der ActionListener hat ja nur zwei Aufgaben.

1. Das ActionEvent abzuhören 
2. Und die "ActionPerformed()" -Methode bereit zu stellen. 

Ist damit gemeint, das der ActionListener die ganzen in einem Programm vorkommenden Event´s abhört und das für Ihn bestimmte Event heraus nimmt??


----------



## Joose (24. Mrz 2016)

In diesem Fall hat "listener" weniger was mit Zuhöhrer zu tun als mit Empfänger (http://www.dict.cc/?s=listener)
Der actionPerformed Methode wird das ActionEvent Objekt übergeben, der Listener empfängt also dieses Objekt und kann darauf reagieren wenn er will.

EDIT: Er empfängt nicht alle Events, sondern er bekommt nur diese welche er "aboniert" hat, indem er sich bei einer Komponente registriert hat (per addActionListener hinzugefügt).


----------



## kneitzel (24. Mrz 2016)

Der hört nichts ab. Den Punkt 1 gibt es nicht. Nur den 2. und das Control muss ihn aufrufen.


----------



## Javaman91 (24. Mrz 2016)

In meinen letzten Post habe ich genau das geschrieben, da war es noch Richtig.
Jetzt ist es wieder Falsch, Ja was nun??

Sorry, aber Ihr verwirrt mich noch mehr.

Genauso stehts hier: http://www.java-tutorial.org/listener.html


----------



## Meniskusschaden (24. Mrz 2016)

Ich glaube, man muß jetzt etwas aufpassen, dass man die Formulierungen nicht allzu sehr auf die Goldwaage legt. Es ist ja umgangssprachlich nicht so ganz eindeutig definiert, was "abhören" bedeutet. Im Zusammenhang mit Listenern ist einfach gemeint, dass dem Listener über seine actionPerformed-Methode, Events von den Quellen mitgeteilt werden, bei denen er sich als Abonnent registriert hat. Im realen Leben würde ein Spion sich natürlich nicht bei seinen Opfern registrieren, um sie abzuhören.


Javaman91 hat gesagt.:


> Genauso stehts hier: http://www.java-tutorial.org/listener.html


In diesem Link ist "Abhören" auch in Anführungszeichen gesetzt. Man sollte es also nicht so wörtlich nehmen.


----------



## Javaman91 (24. Mrz 2016)

Das heißt, das der ActionListener nur eine ActionPerformed - Methode implementiert und sonst nichts?


----------



## kneitzel (24. Mrz 2016)

Die actionPerformed Funktion muss der ActionListener haben, sonst compiliert es nicht. Diese Funktion muss somit da sein. Aber das heisst nicht, dass eine Klasse, die ActionListener implementiert, nicht noch mehr Funktionalität enthält.


----------



## Blender3D (24. Mrz 2016)

Stell Dir das so vor: Der Button erhält einen Klick. Und der Button hat eine Liste vom Typ ActionListener.
Jetzt läuft der Button eine Schleife durch und ruft die ActionPerfomed Methode aller ActionListener auf.
Wenn Du mittels addActionListener Deine Klasse hinzugefügt hast, dann wird dein Klasse auch aufgerufen.
Das heist Dein Klasse wartet auf so einen Aufruf und ist eben ein Zuhörer.


----------



## kneitzel (25. Mrz 2016)

Und wir können uns ja auch einmal einen einfachen ActionListener ansehen:

```
public class MyActionListener implements ActionListener {
  public void actionPerformed(ActionEvent e) {
  }
}
```

Was macht diese Klasse? Was kann eine Instanz dieser Klasse?
Alles was sie macht ist das Anbieten der actionPerformed Funktion. Die kann man aufrufen.
Und die Klasse erbt von Object. Dadurch gibt es ein paar Funktionen wie equals, toString und so.

Und mehr ist da nicht. Da kommt nicht auf irgend eine magische Weise mehr dazu. Kein Code der irgendwas "abhört" oder so.

Und wie mit jeder Funktion innerhalb einer Instanz: Damit man diese Funktion in der Instanz aufrufen kann, braucht die aufrufende Stelle eben die Referenz auf diese Instanz. Und die wird meistens per addActionListener(ActionListener) übergeben.


----------



## Javaman91 (25. Mrz 2016)

Warum kann das keiner einfach und verständlich erklären?

Ich verstehe immer weniger!

Der ActionListener stellt ja nur die actionPerformed-Methode bereit.
Wird ein Button gedrückt, dann ruft der Button die actionPerformed Methode auf.

Mehr macht der ActionLitener doch nicht.


----------

