Müssen ActionListener + sein Button in einer Klasse liegen?

[ggirl]

Hallo,

ich spiele gerade mit dem CardLayout rum und habe mir mehrere JPanels mit Buttons gebaut.

Die Buttons heißen "Hilfe","Start" und "Beenden"

Auf Panel 1 sind sie alle 3 drauf, auf Panel 2 nur noch "Start" und "Beenden". Statt dem "Hilfe"-Button ist ein Image-Icon platziert.

Dann gibt es noch eine inner Klasse

MyActionListener implements ActionListener{
...
}

die die Funktionalität steuert.

Interessehalber habe ich dann versucht, die einzelnen Karten (JPanels) aus meiner Klasse CardLayoutTest mal in eigene Klassen zu legen und diese dann über

...
testpanel 1 = new Testpanel1();
testpanel 2 = new Testpanel2();
...

zu erzeugen.

Funzt auch alles, allerdings weiss ich nicht so recht wohin mit der inneren Klasse MyActionListner.

Will die ActionPerformed-Methode eigentlich nicht in Testpanel1 und nochmals in Testpanel2 legen, weil beide Panels ja einen "Start"-Button haben, der seine Funktion nicht verändert.

Kann man es in Java irgendwie hinbekommen, dass man, wenn man auf mehreren Panels ButtonInstanzen von einem Objekt hat, die das gleiche machen sollen, die Definition der Methode

public void actionPerformed(){
...
}

in eine Art Controller-Klasse legt und daher nur einmal definieren muss?

Hab das so probiert - der Compiler motzt auch nicht, aber ich bekomme einen Laufzeitfehler (StackOverflow).
Laufzeitehler bekomm ich auf folgenden Code:

JButton buttonx = new JButton("Start");
buttonx.addActionListener(new MyActionListener());

MyActionListener soll meine "Controller-Klasse" sein.
Sie definiert, wie sich das Cardlayout über Buttondruck ändern soll.


Mein Problem gehört zur Thematik "da möchte man als Anfänger mal nicht nur einfach alles in eine Klasse stopfen sondern modularer denken, und schon geht nix mehr" ... in einer einzigen Klasse implementiert lief der Code einwandfrei...


Kann mir jemand sagen, ob man in JAVA sowas mir ausgelagerten ActionListener-Contoller-Klassen überhaupt macht / machen darf / machen kann??

 

[Kim Stebel]

1) Ja klar darf man, soll man sogar (meistens).
2) Stack overflow könnte auf eine Endlosschleife hinweisen...
3) Code von MyActionListener posten, sonst kann man nur spekulieren.

 

[ggirl]

Hallo,

bitte nicht wundern, die Variablennamen im Code passen nicht ganz zum Beispiel, weil ich für die Erklärung meines Problems eindeutigere genommen habe...

Die Buttons hier sind selbst definierte, was aber an der Problematik nichts ändern sollte...es lief ja schon einmal als es alles in einer Klasse stand...

    public class MyActionListener extends Gui implements ActionListener{
		public void actionPerformed(ActionEvent event){
			Object object = event.getSource();
			if (object instanceof RulesButton){
				mainLayout.show(layoutkarten,"spielregeln");
				naviLayout.show(navikarten, "spielregeln");
			}	
			else if (object instanceof StartButton){
				mainLayout.show(layoutkarten,"spielplan");
				naviLayout.show(navikarten, "spielplan");
			}	
			else if (object instanceof ExitButton){
				System.exit(0);
			}	
			else if (object instanceof HelpButton){
				mainLayout.show(layoutkarten,"spielregeln");
				naviLayout.show(navikarten, "hilfe");
			}
			else if (object instanceof ContinueButton){
				mainLayout.show(layoutkarten,"spielplan");
				naviLayout.show(navikarten, "spielplan");
			}
		}
	}

Vielleicht hilft auch das weiter: der Code einer der Layoutkarten:

public class NaviLayoutIntro extends JPanel{
	
    protected RulesButton rulesButton; 
    protected StartButton startButton; 
    protected ExitButton exitButton;
	
	
    public NaviLayoutIntro(){
		
        setLayout(new FlowLayout(FlowLayout.RIGHT,0,0));
		
        rulesButton = new RulesButton();
        startButton = new StartButton();
        exitButton = new ExitButton();
		
        this.add(rulesButton);
        this.add(startButton);
        this.add(exitButton);
	
        // Listener registrieren
        MyActionListener myListener = new MyActionListener();
        rulesButton.addActionListener(myListener);
        startButton.addActionListener(myListener);
        exitButton.addActionListener(myListener);
	
}

Wo müssen eigentlich die von mir definierten addActionListener-Methoden hin? In den Contoller, in die Gui, oder in jede Layoutkarte, die Buttons hat???

 

[ggirl]

Hab sie jetzt in jede Layoutkarte, da ich es aus Vorlesungen nicht anders gewöhnt bin...Prog läuft aber immer noch nicht....

ist echt zum verzweifeln :roll:

 

[ggirl]

Der StackOverflow kommt von einer Endlosschleife zwischen dem Erzeugen eines neuen Objekts der Klasse MyActionlistener und findet laut eclipse zwischen dem new-Operator, der Klasse MyActionlistener und dem Versuch, eine Layoutkarte zu erzeugen (in der wiederum der new-Operator von MyActionListener aufgerufen wird), statt.

Weiss jemand von euch, warum das passiert und was man dagegen tun kann?

 

[ggirl]

Habe das Problem inzwischen selber gelöst. Weiss zwar nicht, ob es eine saubere Lösung ist, aber es klappt, wenn man in der Gui-Klasse das CardLayout und die dazu gehörigen Karten als static deklariert und dafür aus der Klasse MyActionListener das "extends Gui" rauslöscht und stattdessen die statischen Variablen der Klasse Gui anspricht.

Was die selbst definierten Action-Performed-Methoden angeht habe ich festgestellt, dass ich diese hier auf Anwenderebene gar nicht mehr brauche. Sie waren nur für die Implementierung meiner selbst erstellten Rollover-Buttons notwendig.

 

[happy_robot]

owei..statics als problemlöser...keine gute idee....böse böse böse

warum baust du nicht eine erstmal eine basisklasse für deine panel Testpanel1 und 2 ?

class BasePanel extends JPanel implements ActionListener {

              private JButton buttonx = new JButton("Start");
 
              protected BasePanel() {
                      buttonx.addActionListener(this); 
              }

              public void actionPerformed(..) {
                  ......
              }

}

class Tespanel1 extends BasePanel {
}

class Tespanel2 extends BasePanel {
}

mfg

 

[ggirl]

Na weil das Base-Panel bei mir nur das aus- und einbleden der Cards des CardLayouts regelt. Die Buttons werden auf Testpanel1 und Testpanel 2 gesetzt, was dann ja heißen würde, dass ich die Methode actionPerformed in Testpanel 1 und und in Testpanel 2 brauche.

Das wäre so betrachtet eine Copy&Paste-Lösung, da Testpanel 1 insgesamt 2 Buttons enthält und testpanel 2 drei Buttons, von denen 2 das gleiche machen wie die Buttons auf Testpanel 1. Nur für dern dritten >Button müsste ich dann etwas neues schreiben.

Sollt später einmal die Buttonfunktionalität geändert werden, muss das dann in 2 Klassen geändert werden. Ich hätte den Code gerne an einer einzigen Stelle, um so Redundanzen zu vermeiden und die eventuelle Anpassung des Programms leichter handeln zu können...

Bei mir ist das BasePanel derzeit noch von JFrame abgeleitet, was ich demnächst auf JApplet umstellen möchte, weil die Sache im Internet laufen soll, und deshalb kann ich das BasePanel nicht von JPanel ableiten, weil ja nur ein extends möglich ist...

 

[happy_robot]

hmmm...ich glaube ich verstehe dein problem nicht so ganz oder wenn ich es richtig verstehen sollte gibt es vielleicht verständnisprobleme deinerseits was OOP angeht.
wenn die funktionalitäten für die buttons unterschiedlich sein sollten MUSST du jeden einzeln implementieren. wenn das verhalten gleich ist implementiere es in der basisklasse und hänge alle buttons dran die dieses verhalten haben sollen. sollte ein anderes verhalten gewünscht sein überschreibst du nur und ausschliesslich die funktionalität in der klasse.

 

[ggirl]

du meinst also, als interne Klasse in der Basisklasse

class MyActionListener implements ActionListener{

    public void actionPerformed(){
        ...
    }
}

anlegen,

dann die Buttons in Testpanel 1 und Testpanel2 erzeugen (dort gibt es jeweils eine Instanz der Klasse StartButton, die in beiden Klassen jeweils "startbutton" benannt ist)

StartButton startbutton = new StartButton();

und in der Basisklasse dann

MyActionListener action = new MyActionListener();
startbutton.addActionListener(action);

in den Code schreiben, und beide startbutton bekommen damit die gleiche funktionalität?

(MyActionListener habe ich derzeit als einzelnen Klasse angelegt, könnte aber auch wieder als interne Klasse zurück in die Basisklasse kopiert werden)

Warscheinlich verstehe ich nicht ganz was damit gemeit ist, GUI und Funktionalität zu trennen (in unseren Vorlesungen wird es immer wieder erwähnt, dass gute Programmierer das trennen). Meine Basisklasse "handelt" das CardLayout. Wenn ich jetzt die Klasse MyActionListener wieder dort reinkopiere, dann ist doch Oberfläche und Fuktionalität wieder in einer Klasse. Ich dachte dass man sowas nicht machen sollte? Wenn ich das jetzt vielleicht falsch verstehe, wo liegt dann mein Denkfehler?

 

[happy_robot]

Ich glaube hier muss man Vor- und Nachteile abwägen. Wenn Du ein API entwickelst das von anderen in Dir unbekannten Umbegungen eingesetzt werden soll musst Du natürlich dafür sorgen daß, im Bestfall, keinerlei direkten Abhängigkeiten entstehen (und wenn dann auch nur über Interfaces).

In Deinem Beispiel bist Du aber eigentlich an der Stelle angelangt wo Du den "Baukasten API" anwendest. Auf Deiner Ebene kommst Du um Abhängigkeiten nicht herum. Du hast eine Funktionalität die in einer Deiner Klassen exakt in dieser Klasse ein bestimmtes Verhalten hervorrufen soll. Dieses zu entkoppeln macht keinen Sinn, da die Funktionalität zu speziell ist daß eine Entkopplung nicht notwendig ist. Hier spricht also IMHO nix dagegen den Listener einfach vor Ort anzuwenden. Wenn Du diesen dennoch auslagerst, wogegen eigentlich auch nichts spricht, wirst Du ihn dennoch wieder irgendwie mit der View koppeln müssen. Wenn Du dann hier dem Controller zum Beispiel eine Referenz der View übergibst (z.b. setView.. oder so) hast Du wieder eine Abhängigkeit. Das wäre also nicht wirklich ein Gewinn.

Ich denke daß auch gute Programmierer es bei der strikten Trennung von View und Controller nicht soooo eng sehen und sich eigentlich auch nicht wirklich die Notwendigkeit dafür ergibt (da bereits von Standard-API gut umgesetzt).
Die klare Trennung vom Datenmodell ist hier deutlich wichtiger und sollte aber immer strikt verfolgt und mit einem Interface implementiert werden!

Nichtdestotrotz finde ich es prima daß Du dir Gedanken darüber machst! Dickes Lob!

 

[Guest]

Danke für deine Antwort!

Finde es auch super, dass du den Topic noch beobachtest, obwohl er schon als erledigt markiert war.

Dank deinen Infos habe ich heute meinen Prof. noch einmal auf die Thematik angesprochen. Er meinte wie du, dass es voll legitim sei, den ActionListener in der Basiklasse zu belassen, weil "ActionListener ja eh nicht zu komplizierte Funktionalitäten regeln sollten" (kann das jetzt nicht so treffend wiedergeben, wie er es erklärt hat). Er wird uns demnächst etwas zum Thema Multithreading erklären, womit sich das dann leichter umsetzten lässt.

Derweil hat er mir vorgeschlagen, meine Klassenstruktur derweil so zu belassen (also mit externer Klasse MyActionListener) und mir einen Trick gezeigt, wie ich das static wegbekomme (nämlich indem ich mit dem this-pointer arbeite).

Finde es super, dass du mich darüber informiert hast, dass static hier nicht die tolle Lösung ist. Dank deiner Infos konnte ich die Sache noch einmal hinterfragen und habe somit für mich etwas gelernt, was einem an der FH bei uns nicht selbstverständlich vermittelt wird. Wir sind momentan vom Wissenstatus noch an der Schwelle, wo man erst einmal froh ist, dass ein Programm läuft - mir ist es aber auch wichtig, dass ich abschätzen kann, ob ich eine Lösung gefunden habe, die auch einigermaßen "sinnvoll" ist. Denke schon, dass ich mir da mehr Gedanken mache als ein Standardstudent...jedoch denke ich, dass das es nicht verkehrt ist, jetzt schon sich genau zu überlegen, warum man den Code so oder anders gestaltet.

Deshalb bin ich sehr froh, dass es hier im Forum Leute gibt, die ihr Wissen mit anderen teilen und einem helfen, das eigene Wissen zu erweitern.