The Java APIs - are we speaking the same language?

Question

Hello again world.
I was reading in someone's response a suggestion to "write a different actionPerformed() method for each button."
So I thought, let me see if I can do that and came up with this:
import  java.awt.*;
import  java.awt.event.*;
import  javax.swing.*;
public  class  MyActionListeners
   private  JButton  myButtons[]  = new  JButton[3];
   public  MyActionListeners()
      myButtons[0] = new  JButton("Button 1");
      myButtons[1] = new  JButton("Button 2");
      myButtons[2] = new  JButton("Button 3");
      myButtons[0].addActionListener(new  ButtonListener());
      myButtons[1].addActionListener(new  ButtonListener());
      myButtons[2].addActionListener(new  ButtonListener());
      JPanel  panel = new  JPanel();
      panel.add(myButtons[0]);
      panel.add(myButtons[1]);
      panel.add(myButtons[2]);
      JFrame  frame = new  JFrame("Action Listeners");
      Container  contentPane = frame.getContentPane();
      contentPane.add(panel);
      frame.pack();
      frame.setLocationRelativeTo(null);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   public  static  void  main(String[]  params)
      new  MyActionListeners();
class  ButtonListener  implements  ActionListener
   public  void  actionPerformed(ActionEvent  ae)
      JOptionPane.showMessageDialog(null , "You pressed " + ae.getActionCommand());
}which works fine but, of course, there's only one actionPerformed() method.
My first program, which I got to work as suggested, had three but when I noticed they all did the same thing (just announce which button was pressed), I decided to further test my skill to see if I could reduce it to the program above.
My question has to do with my difficulty in locating that getActionCommand() method.
It's not that it was actually difficult to find, it's more that I saw it and figured it was not what I was looking for.
The API describes the getActionCommand() method as "Returns the command string associated with this action."
I thought, "command string . . . I don't need no stinkin' command string"
I naturally tried the paramString() and the inherited toString() and getSource() methods first.
Indeed, it was the API description for the return value of paramString() - "a string identifying the event and its associated command" - that clued me in to looking at the getActionCommand() method.
So, why is my button text considered a "command string"?
I'm not playing semantics, I'm just trying to understand how to read the APIs.
Thank you one and all.
Ciao for now.

Answer 1

Anyway, for buttons, typically, what I do is either:
1) 1 listener for all buttons, usually the same class:
public class MyClass implements ActionListener {
   public MyClass() {
      button1.setActionCommand("new");
      button1.addActionListener(this);
      ... etc. for each button...
   public void actionPerformed(ActionEvent ae) {
      if("new"equals(ae.getActionCommand()) {
         doNewThing();
      } else if(...) ...
   public void doNewThing() {
      // do new stuff...
}The advantage here is that often you have buttons and menu items (which are buttons) and maybe even text fields which all fire action events for the same command, and can use the same listener.
The disadvantage here is that you typically end up with long sets of if/else statements to check for each command.
A modification on this is not using action commands, but if the buttons are all variables defined at the class level, you can use the event source to check if it's this or that component.
2) Use anonymous listeners to call methods.
public class MyClass implements ActionListener {
   public MyClass() {
      button1.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent ae) {
            doNewThing();
      ... etc. for each button...
   public void doNewThing() {
      // do new stuff...
}The disadvantage (sorta) is you end up with a lot of MyClass$#.class files. Of course, using Ant to compile and package everything in a Jar makes this more or less a non-issue. And it does often look cleaner. But doing that means you have separate listeners for the button and the menu item and whatever, which may call the same class. You can, of course, create 1 listener and reuse it for multiple components:
public class MyClass implements ActionListener {
   ActionListener newListener = new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
         doNewThing();
   public MyClass() {
      button1.addActionListener(newListener);
      ... etc. for each button...
   public void doNewThing() {
      // do new stuff...
}3) You can also use Action classes, which incorparate the action listener and several other things (text, icon, etc) for a button or menu. But honestly, I almost never use this.
4) Option 4 this code I wrote here:
http://forum.java.sun.com/thread.jspa?forumID=31&threadID=548168
An example based on what I've already shown using that would be:
public class MyClass implements ActionListener {
   public MyClass() {
      button1.addActionListener(new MethodInvokeAction(this, "doNewThing"));
      ... etc. for each button...
   public void doNewThing() {
      // do new stuff...
}I've used all these ways in real apps. Generally, I use something like 2 (a or b) if there's lots of buttons and menus, and 1 if there's only a few buttons. The one app that I wrote the MethodInvokeAction class for, I actually used several ways.