如何为多个JMenuItem创建ActionListener？

Question

I'm having difficulty using anonymous inner classes with actionListener. Can someone explain to me what is wrong with my code and how to use anonymous inner classes with actionListener. I'm trying to make a menu bar in one class and the action listener in the other. I ran into some difficulty when I tried using anonymous inner classes. The java website wasn't clear. Can you please explain it to me and help me fix my code.

 public class Listener implements ActionListener {
        HangmanView hangmanView = new HangmanView();
        JFrame dialogFrame = new JFrame();
        ImageIcon logo = new ImageIcon("logo.png");

        public void listener1() {
            hangmanView.getMenuItem().addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {// right click key
                    JOptionPane.showMessageDialog(dialogFrame, "Developer: Joe"
                            , "Developer",
                            JOptionPane.INFORMATION_MESSAGE, logo);
                }// end actionPerformed method
            });
        }
    }

another class:

public class HangmanView {

    public JMenuItem getMenuItem() {
        JMenuItem menuItem = new JMenuItem("Developer", KeyEvent.VK_T);
        menuItem.addActionListener(new Listener());
        return menuItem;
    }

    public JMenuBar menuBar() {

        JMenuBar menuBar = new JMenuBar();
        JMenu menu = new JMenu("File");
        menuBar.add(menu);
        menu.add(getMenuItem());// return here
        return menuBar;
    }

Answer 1

If you're trying to implement the listener for different JMenuItem s, what I would do instead is create a custom Action class that you can use for multiple JMenuItem s, as JMenuItem s are a good example of when to use an Action .

private class MyAction extends AbstractAction {

    String name;

    public MyAction(String name, Icon icon) {
        super(name, icon);
        this.name = name;
    }

    public MyAction(String name, Icon icon, String desc,
            Integer mnemonic, KeyStroke accelorator) {
        super(name, icon);
        putValue(Action.SHORT_DESCRIPTION, desc);
        putValue(Action.MNEMONIC_KEY, mnemonic);
        putValue(Action.ACCELERATOR_KEY, accelorator);
        this.name = name;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        switch (name) {
            case "menu1Action":
                // do something for menuItem1
                break;
            case "menu2Action":
                // do something for menuItem2
                break;
            case "menu3Action":
                // do something for menuItem3
                break;
        }
    }
}

Have this class as an inner class of HangmanView . You can then create an instance of this custom Action class for each JMenuItem . Here's a example

Action menu1Action = new MyAction(
 /* arg 1 */    "menu1Action", 
 /* arg 2 */    someIcon,
 /* arg 3 */    "Some Short description of the action",
 /* arg 4 */    new Integer(KeyEvent.VK_T),
 /* arg 5 */    KeyStroke.getKeyStroke(KeyEvent.VK_T, ActionEvent.CTRL_MASK));

• The first argument is the name of the action. This name will be the name that you will see in the menu
• The second argument is the icon that you will see in the menu next to the name.
• The third argument is the Description of the menu item action
• The fourth argument is the Mnemonic (ie Alt + T ).
• The fifth argument is the Accelerator (ie Ctrl + T ).

When you add an Action to a JMenu , the title of that Action will automatically get placed as what you see in the JMenu . So all you need to do is add this custom Action to your JMenu . You don't ever have to actually create a JMenuItem at all. The Action will serve as the replacement for the JMenuItem . Just add all your MyAction objects to the JMenu .

menu.add(menu1Action);

What I have left out, is the implementation for each separate switch case in the actionPerformed . The case will be what you name the action in the constructor. Because I named the Action "menu1Action", I should have the corresponding name in the the switch case. In that case, you can do your JOptionPane or what ever else you wish to perform when that JMenuItem is clicked or accessed by keyboard.

Another great benefit of using an Action is that it can serve multiple purposes. With the same MyAction menu1Action you created, you can use the same Action for a JToolBar . Without any alteration to the above menu1Action , you could just do this:

JTooBar toolbar = new JToolBar();
toolbar.add(menu1Action);

Now in your tool bar and in your menu item, you have the same action. The tool bar will only show the icon and not the name.

Here is an example. What I do is create three different MyAction objects. One for left-alignment, one for center-alignment, and one for right-alignment. Each of these actions is used three separate times for three separate components, a menu item, a toll bar and a button

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ActionInterfaceDemo extends JFrame {
    static JPanel buttonPanel = new JPanel();
    static FlowLayout flowLayout = new FlowLayout();

    public ActionInterfaceDemo(){


        ImageIcon centerIcon = new ImageIcon(
                ActionInterfaceDemo.class.getResource("image/centeralignment.png"));
        ImageIcon rightIcon = new ImageIcon(
                ActionInterfaceDemo.class.getResource("image/rightalignment.png"));
        ImageIcon leftIcon = new ImageIcon(
                ActionInterfaceDemo.class.getResource("image/leftalignment.png"));

        Action leftAction = new MyAction("Left", leftIcon,
                "Left alignment for the buttons in the panel",
                new Integer(KeyEvent.VK_L),
                KeyStroke.getKeyStroke(KeyEvent.VK_L, ActionEvent.CTRL_MASK));
        Action rightAction = new MyAction("Right", rightIcon,
                "Right alignment for the buttons in the panel",
                new Integer(KeyEvent.VK_R),
                KeyStroke.getKeyStroke(KeyEvent.VK_R, ActionEvent.CTRL_MASK));
        Action centerAction = new MyAction("Center", centerIcon,
                "Center alignment for the buttons in the panel",
                new Integer(KeyEvent.VK_C),
                KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK));

        JMenuBar menuBar = new JMenuBar();
        JMenu menuAlignment = new JMenu("Alignment");
        setJMenuBar(menuBar);
        menuBar.add(menuAlignment);

        menuAlignment.add(leftAction);
        menuAlignment.add(centerAction);
        menuAlignment.add(rightAction);

        JToolBar toolBar = new JToolBar("Alignment");
        toolBar.setBorder(BorderFactory.createLineBorder(Color.BLUE));
        toolBar.add(leftAction);
        toolBar.add(centerAction);
        toolBar.add(rightAction);

        buttonPanel.setLayout(flowLayout);
        JButton jbtLeft = new JButton(leftAction);
        JButton jbtCenter = new JButton(centerAction);
        JButton jbtRight = new JButton(rightAction);
        buttonPanel.add(jbtLeft);
        buttonPanel.add(jbtCenter);
        buttonPanel.add(jbtRight);

        add(toolBar, BorderLayout.EAST);
        add(buttonPanel, BorderLayout.CENTER);

        pack();
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable(){
            public void run(){
                new ActionInterfaceDemo();
            }
        });

    }

    private class MyAction extends AbstractAction {

        String name;

        public MyAction(String name, Icon icon, String desc,
                Integer mnemonic, KeyStroke accelorator) {
            super(name, icon);
            putValue(Action.SHORT_DESCRIPTION, desc);
            putValue(Action.MNEMONIC_KEY, mnemonic);
            putValue(Action.ACCELERATOR_KEY, accelorator);
            this.name = name;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            switch (name) {
                case "Left":
                    flowLayout.setAlignment(FlowLayout.LEFT);
                    break;
                case "Right":
                    flowLayout.setAlignment(FlowLayout.RIGHT);
                    break;
                case "Center":
                    flowLayout.setAlignment(FlowLayout.CENTER);
                    break;
            }
            buttonPanel.revalidate();
        }
    }
}

You can press the "Left" in either the menu, the toolbar, or the button and they will produce the same result, as they are derived from the same Action .

Here are the images I used if you want to test it out

Note You don't have to use either of these exact constructors. You can create your own with different arguments. This is just a custom one I like to use.

Aslo See How to use Action tutorial

Answer 2

Listener , being an ActionListener through its inheritance hierarchy,

public class Listener implements ActionListener {

needs to implement an actionPerfomed(ActionEvent) method

@Override
public void actionPerformed(ActionEvent e) {
    // implement it         
}

However, since you seem to be adding an anonymous ActionListener , just don't have your Listener class implement ActionListener . Remove that bit.

Answer 3

Your object-oriented programming is all over the place. Your code in the OP looks like it's supposed to be some kind of GUI with different classes somehow working together but it's just creating new objects all over the place. There are too many reasons it doesn't work. I'd suggest you stick to something simple until you have a better grasp on how all this works.

You also got a very good suggestion in your other question that's a lot like this one but you haven't really followed it. Your code does something completely different.

Here is a very basic GUI. You have one object that has everything as fields. Everything is in one place. The containing object is the listener and decides what to do based on the event source. You should stick with a design like this until you are more comfortable with OOP.

public class HangmanView
implements ActionListener {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new HangmanView().setFrameVisible(true);
            }
        });
    }

    private JFrame theFrame = new JFrame("Main Window");
    private JPanel theContent = new JPanel();

    private JMenuBar theBar = new JMenuBar();
    private JMenu fileMenu = new JMenu("File");
    private JMenuItem exitMenuItem = new JMenuItem("Exit");
    private JMenuItem devMenuItem = new JMenuItem("Developer");

    public HangmanView() {
        assert SwingUtilities.isEventDispatchThread();

        exitMenuItem.addActionListener(this);
        devMenuItem.addActionListener(this);

        fileMenu.add(exitMenuItem);
        theBar.add(fileMenu);
        theBar.add(devMenuItem);

        theContent.setPreferredSize(new Dimension(500, 500));

        theFrame.setJMenuBar(theBar);
        theFrame.setContentPane(theContent);
        theFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        theFrame.pack();
        theFrame.setLocationRelativeTo(null);
    }

    public void setFrameVisible(boolean vis) {
        theFrame.setVisible(vis);
    }

    @Override
    public void actionPerformed(ActionEvent ae) {
        if(ae.getSource() == devMenuItem) {
            showDevDiag();
        } else if(ae.getSource() == exitMenuItem) {
            systemExit();
        }
    }

    private void showDevDiag() {
        JOptionPane.showMessageDialog(
            theFrame,
            "Developer: Joe",
            "Developer",
            JOptionPane.INFORMATION_MESSAGE,
            null
        );
    }

    private void systemExit() {
        System.exit(0);
    }
}

Answer 4

if I should use anonymous class, that's what should be done:

public static void main(String args[]){
    /*bla bla bla...*/
    JButton button1=new JButton("button1");
    button1.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent ae){
            /*bla bla bla...*/
        }
    };
}

On the other hand, I always do this:

public class Class implements Runnable,ActionListener
{
    private static Map<Thread,ActionEvent> THREAD_ATTRIB
    =new HashMap<Thread,ActionEvent> (0);

    JButton button1=new JButton("button1");
    JButton button2=new JButton("button2");
    //constructor
    public Class(){
        this.button1.addActionListener(this);
        this.button2.addActionListener(this);
    }

    @Override
    public void actionPerformed(ActionEvent ae){
        Thread thread=new Thread(this);
        THREAD_ATTRIB.put(thread,ae);
        thread.start();
    }

    @Override
    public void run(){
        ActionEvent ae=THREAD_ATTRIB.get(Thread.currentThread());
        if(ae!=null){
            Object source=ae.getSource();
            if(source.equals(this.button1){
                /*bla bla bla...*/
            } else if(source.equals(this.button2){
                /*bla bla bla...*/
            }
        } else{
            /*bla bla bla...*/
        }
    }
}