Mehrere Buttons mit einem ActionListener abdecken

favas

Mitglied
Hallo,
ich bin dabei Java zu lernen und habe mir nun vorgenommen mittels Java Swing ein paar grafische Komponenten auszutesten. Dabei bin auf JMenu gestoßen. Meine eigentliche Frage ist wie ich es hin bekomme, dass ich mit nur einem ActionListener alle JMenuIcons abdecke, ich schaffe es zwar diese zu verbinden aber weiß nicht wie je nach Quelle etwas anderes passieren soll.

Java:
package pack1;

// import declarations

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

public class Fenster {

    // variables
    private JMenuBar mb;
    private JFrame fenster;
    private JMenu[] m;
    private String[] namen = {"File","Edit", "Search"};
    private JMenuItem[][] mi = {{new JMenuItem("New"), new JMenuItem("Open File"), new JMenuItem("Close")},
                                {new JMenuItem("Copy"), new JMenuItem("Paste"), new JMenuItem("Delete")},
                                {new JMenuItem("File"), new JMenuItem("Java"), new JMenuItem("Remote")},
                                };
    private ActionListener[] al=    {new MeinActionListener()};

   
    //method
    public void FensterMachen() {
   
   
    fenster = new JFrame();
    fenster.getContentPane().setBackground(Color.cyan);
    fenster.setSize(500,500);
   
   
    mb = new JMenuBar();
    m = new JMenu[3];
   
    for(int i = 0 ; i<m.length;i++) {
        mb.add(m[i] = new JMenu("" + namen[i]));
       
        for(int j = 0; j<3;j++) {
            m[i].add(mi[i][j]);
        mi[i][j].addActionListener(al[0]);
        }
       
    }
   
    fenster.setJMenuBar(mb);
    fenster.setVisible(true);
   
    }

    //Listener
    public class MeinActionListener implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent arg0) {
            Object quelle = arg0.getSource();
   
        }
       
    }
   
}
 
Mit getActionCommand kannst du den Namen der gekilckten Komponente herausfinden.

Java:
class MeinActionListener implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent arg0) {
           String action = arg0.getActionCommand();
 
           if(action.equals("File")) {        
           }
        
           if(action.equals("Open")) {         
           }
        
        }
 
 }
 
Zuletzt bearbeitet:
@favas Beschreib doch büdde nochmal genau was Du willst....
Hast Du schonmal von Casten gehört?
Du kannst die Rückgabe von .getSource() casten.
 
Kannst auch einfach mit einer switch-case die einzelnen Fälle abdecken. (oder eben mit if-else)
Java:
@Override
public void actionPerformed(ActionEvent e) {
    switch(e.getSource()) {
        case menuItem1:
             doSomething();
             break;
        case menuItem2:
             doSomething2();
             break;
        ...
    }
}
Du kannst die Rückgabe von .getSource() casten.
Und dann?

Na weil sich der Text des Button immer ändern kann
Dann macht man eben Konstanten draus. Dann ist es egal ob die sich ändern.
 
Fachsimpeln ist ja okay .. sollte dann aber auch zum Thema passen.
Gibt es hier noch welche Fragen? Bad practice und Gründe habe ich genannt.
Auch der konstruktive Lösungsvorschlag (good practice) ist dabei.


sehe hier auch keinen Grund, zu casten.
Im Nachfolgendem wird er sicher auf Attribute des Button greifen wollen.


casten verändert den dynamischen Typ nicht
Grundl. nachlesen bitte.
 
Grundl. nachlesen bitte.
Was soll man da denn noch nachlesen? Kann man doch einfach ausprobieren:
Java:
    public static void main(String[] args) {
        Object object = new JButton();
        System.out.println(object.getClass());
        JButton button = (JButton)object;
        System.out.println(button.getClass());
    }
Ausgabe:
Code:
class javax.swing.JButton
class javax.swing.JButton
 
Ok es steht 1:2000 für euch. 😀😀
Thema gegesenn und morgen gehts weiter.

Bearbeitung: heute 😕
 
Meine eigentliche Frage ist wie ich es hin bekomme, dass ich mit nur einem ActionListener alle JMenuIcons abdecke, ich schaffe es zwar diese zu verbinden aber weiß nicht wie je nach Quelle etwas anderes passieren soll.
Code:
..
 item.setActionCommand("hallo");
..
Code:
..
public void actionPerformed(ActionEvent e) {
if ( e.getActionCommand().equals("hallo") )
..
Das wäre eine Möglichkeit
 
Da ja auf die Frage schon antworten kamen, warum willst du denn alle Menü-Einträge mit einem ActionListener abdecken?
 
Ok, vielen Dank schon mal
Ich war einfach dabei die Sachen ein bisschen auszuprobieren und dachte, dass man mit einem ActionListener für alle Buttons vielleicht weniger schreiben muss, aber das scheint ja dann wohl nicht so zu sein.
Dann noch eine Frage, ist es besser (oder schöner) für jeden Button einen eigenen Listener zu erstellen?
 
Zuletzt bearbeitet:
Als Neuling habe ich auch einen einzelnen ActionListener bevorzugt. Mittlerweile bin ich auf die Anonyme Klassenvariante umgestiegen als favorisierte Vorgehensweise. Mit Lambda kannst du es verkürzt so schreiben:

Java:
button.addActionListener(e -> {
            // tu etwas
        });
 
Vielen Dank euch allen,
Mittlerweile bin ich auf die Anonyme Klassenvariante umgestiegen als favorisierte Vorgehensweise. Mit Lambda kannst du es verkürzt so schreiben:
Interessant, das werde ich mir auf jeden Fall genauer anschauen🙂
dann hab ich zunächst keine weiteren Fragen mehr.
 
Letztendlich ist das alles Geschmackssache. Das ActionCommand ist dann eine gute Alternative, wenn die Quelle nicht wichtig ist, wenn du z.B. einen Toolbar-Button UND ein Menu hast, die beide den "Datei Öffnen" Dialog aufrufen sollen.
Mit getSource() kriegst du hingegen das Objekt geliefert, von welchem aus der Event erstellt wurde.
Mit Lambdas weist du jedem Button mit relativ wenig Schreibaufwand einen eigenen Listener zu, das ist die direkteste Methode. Allerdings heißt das auch, dass du den Code für jeden Listener in der Methode hast, in der die Buttons initialisiert werden.
Ich hab das gern getrennt, deswegen verwende ich eine Methode außerhalb der Initialisierungsmethode als Listener (wird mit addActionListener(this::myMethodWhichAccepptsAActionCommand) zugewiesen.
In der Methode frage ich dann einfach mit getSource die Quelle ab.
 
Ich nutze einfach eine eigene Methode pro möglicher Aktion, die wird dann den entsprechenden Buttons als Methodenreferenz übergeben.

Alles liegt dann in Methoden, die machen jeweils genau eine Sache und man muss weder mit Source noch ActionCommands rumhantieren.

(Mit JavaFX und FXML hält man dann auch noch die Zuordnung aus dem Code raus)
 

Neue Themen


Zurück
Oben