# Action Listener in innerer Klasse ausführen.



## shanahan (14. Jan 2012)

Hallo Leute,

ich hab folgendes Problem: Ich soll ein kleines Programm zur Simulation eines Bankautomaten schreiben.
Dabei kann man zu Beginn auf dem Bildschirm über die Buttons auswählen2 und auswählen 3 zwischen der Option Beenden und der Option einloggen wählen. Wenn die Option einloggen gewählt wird, soll man auf dem Bildschirm über ein Numpad seine Kontonummer eingeben. Hier nun mein Problem: Ich habe die Buttons auswählen2 und auswählen 3 in einen ActionListener eingefügt; wird nun auswählen3 gedrückt, schließt das Programm ohne Probleme. Drücke ich aber auswählen 2, sollte er eigentlich in der inneren Klasse die Methode actionperformed aufrufen und die Zahlen, die gedrückt werden, auf dem Bildschirm ausgeben(der Einfach halt halber habe ich bis jetzt nur den einser button zum ActionListener hinzugefügt).
Anscheinend wird aber diese methode in der inneren Klasser erst garnicht aufgerufen  .
Habt ihr irgendeine Idee wie ich das implementieren kann?
Vielen Dank schonmal im Vorraus.



```
public void zum_ActionListener_hinzufügen()
    {
        auswählen1.addActionListener(this);
        auswählen2.addActionListener(this);
        auswählen3.addActionListener(this);

        bestätigen.addActionListener(this);
    }

    public void actionPerformed(ActionEvent e)
    {
        Object object = e.getSource();
        if(auswählen3 == object)
        {
            bildschirm.setText("Vielen Dank für ihren Besuch");
            System.exit(0);
        }

        else if(auswählen2 == object)
        {
            bildschirm.setText("Bitte geben Sie nun im folgenden Ihre Kontonummer ein");
            
            class einloggen implements ActionListener
            {

                public einloggen()
                {
                    eins.addActionListener(this);}

                public void actionPerformed(ActionEvent e)
                {
                    Object object = e.getSource();

                    if(object == eins) {
                        bildschirm.setText("1"); ;}

                    else if(object == zwei) {
                        bildschirm.append("2"); }

                    else if(object == drei) {
                        bildschirm.append("3"); }

                    else if(object == vier) {
                        bildschirm.append("4"); }

                    else if(object == fünf) {
                        bildschirm.append("5"); }

                    else if(object == sechs) {
                        bildschirm.append("6"); }

                    else if(object == sieben) {
                        bildschirm.append("7"); }

                    else if(object == acht) {
                        bildschirm.append("8"); }

                    else if(object == neun) {
                        bildschirm.append("9"); }

                    else if(object == Null) {
                        bildschirm.append("0"); }

                    else if(object == bestätigen) {

                    } } }

        }
```


----------



## turtle (14. Jan 2012)

Ich mag diese Art der Programmierung nicht, wo in einem ActionListener geprüft wird, welches Objekt eigentlich der Auslöser war und dann verzweigt. Erinnert mich an frühere, nicht-OO, Zeiten

Ich implementiere für so etwas immer anonyme ActionListener-Klassen.

```
auswählen1.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				// Dein Code
				}
			}

		});
```
 Damit ist klar, welcher Listener zuständig ist und man muss nicht in einer riesigen Verteil-Schleife rumfuhrwerken. Dein Ansatz macht nur in seltenen Fällen Sinn, wenn nämlich der Code im ActionListener praktiisch immer der gleiche ist.


----------



## Marcinek (14. Jan 2012)

Man würde hier eher jedem Button die Information, die er anhängen soll nachdem man ihn gedrückt hat mitgeben.

Die anonymen Listener sind hier kaum ein Vorteil.


----------



## shanahan (14. Jan 2012)

Na was denn nun, anonyme Listener oder nicht?


----------



## pl4gu33 (14. Jan 2012)

schau mal hier 

http://www.java-forum.org/java-basi...istener-anonymous-inner-class-main-class.html


----------



## shanahan (14. Jan 2012)

pl4gu33 hat gesagt.:


> schau mal hier
> 
> http://www.java-forum.org/java-basi...istener-anonymous-inner-class-main-class.html



Danke, werd ich mir mal anschauen.


----------



## bERt0r (14. Jan 2012)

Da ich mal annehme, dass der Text deines Buttons einfach die Zahl ist die er repräsentiert, kannst du auch einfach auf die getActionCommand Methode zugreifen. Die liefert standardmäßig den Text des Buttons zurück, von dem der Aufruf kam.

```
class NumButtonActionListener implements ActionListener
	{
		@Override
		public void actionPerformed(ActionEvent e)
		{
			String text=textField.getText();
			text=text.concat(e.getActionCommand());
			textField.setText(text);
		}
	}
```


----------



## GUI-Programmer (14. Jan 2012)

shanahan hat gesagt.:


> Na was denn nun, anonyme Listener oder nicht?



Also falls es für dich Sinn macht nach MVC zu programmieren, also dein Projekt schon etwas größer ist, dann solltest du weder innere noch anonyme Klassen für deine Listener verwenden, sondern Klassen, die Listener implementieren. Siehe MVC Beispiel aus meiner Signatur.

Ansonsten, wenn dein Projekt nur aus ein paar Klassen besteht (<5) und diese auch nicht gerade groß sind (<500 Zeilen) dann würde ich dir raten anonymen Klassen zu benutzen.


----------



## Camino (14. Jan 2012)

Hmm, es gibt ja auch noch die Möglichkeit, sich Action-Klassen (abgeleitet von AbstractAction) anzulegen, die man dann beim Erstellen der Buttons einfach mit übergibt. Ist ja dann eigentlich ähnlich wie ein ActionListener, hat also auch die Methode actionPerformed mit dem ActionEvent. Wie ist das eigentlich im Vergleich zu den anderen Möglichkeiten einzuschätzen? Besser, schlechter, egal?


----------

