There are 2 ways (that I know of and can remember from class) for
designing the way your application handles the action events.  You can
have your JFrame or JPanel (some central "authority") manage all the
events which would cause you to need a bunch of "else if" statements or
you can have each button be its own action listener which removes the
need for a large "if" structure but makes the individual button code a
little more messy, IMO.

Brandon

With you program just implement an ActionListener. After this you have
to add the required actionPerformed method. Then just check for which
buttons were selected. Here is an example code for buttons objects.
Naturally this is not a complete program but just info you were asking about

public class MyButtons implements ActionListener
{
    private JButton deleteButton;
    private JButton reloadButton;
    private JButton returnButton;
    private JButton commitButton;

    private final String        TEXT_DETELE           = "Delete";
    private final String        TEXT_RELOAD           = "Reload";
    private final String        TEXT_RETURN           = "Return";
    private final String        TEXT_COMMIT           = "Commit";

    private final String        _Click                = "Click this
button to ";
    private final String        _toolTipDelete        = this._Click +
"Deleteed Se;ected quote from Database";
    private final String        _toolTipReload        = this._Click +
"Reload all remaintng dupicate Quotes from Database";
    private final String        _toolTipReturn        = this._Click +
"Return Insert Quotes";
    private final String        _toolTipCommit        = this._Click +
"Commit all Delete's to Database";

     public MyButtons ()
    {
      deleteButton = buildButton (deleteButton, TEXT_DETELE,
KeyEvent.VK_D, _toolTipDelete));
      reloadButton = buildButton (reloadButton, TEXT_RELOAD,
KeyEvent.VK_R, _toolTipReload));
      returnButton = buildButton (returnButton, TEXT_RETURN,
KeyEvent.VK_X, _toolTipReturn));
      commitButton = buildButton (commitButton, TEXT_COMMIT,
KeyEvent.VK_C, _toolTipCommit));
    }

    private JButton buildButton (JButton jButton, String label, int
keyEvent, String toolTip)
    {
        jButton = new JButton(label);
        jButton.setMnemonic (keyEvent);
        jButton.addActionListener (this);
        jButton.setActionCommand (label);
        jButton.setToolTipText (toolTip);
        return jButton;
    }
    public void actionPerformed (ActionEvent e)
    {
        if (this.TEXT_RETURN.equals (e.getActionCommand ()))
        {
        }
        else if (this.TEXT_DETELE.equals (e.getActionCommand ()))
            {
            }
            else if (this.TEXT_RELOAD.equals (e.getActionCommand ()))
                {
                }
                else if (this.TEXT_COMMIT.equals (e.getActionCommand ()))
                    {
                    }

    }
}

Thanks in Advance...
IchBin, Pocono Lake, Pa, USA              http://weconsultants.phpnet.us
__________________________________________________________________________

'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor,  Regular Guy (1952-)

I personally prefer a design-pattern
roughly alongside the article "How to use Action" at
<http://java.sun.com/docs/books/tutorial/uiswing/misc/action.html>.

My code typically looks like this:

//--begin example-------------------------------------------------
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MainFrame extends JFrame {
  public static void main(String[] args) {
    JFrame frame = new MainFrame();
    frame.pack();
    frame.setVisible(true);
  }

  // Actions used by menu items and buttons:
  private Action openAction = new OpenAction();
  private Action saveAction = new SaveAction();
  // ...more actions

  public MainFrame() {
    jbInit();
  }

  private void jbInit() {
    getContentPane().setLayout(new BorderLayout());

    JMenuBar menuBar = new JMenuBar();
    JMenu fileMenu = new JMenu("File");
    fileMenu.add(openAction);
    fileMenu.add(saveAction);
    menuBar.add(fileMenu);
    // ... more menus and menu-items
    setJMenuBar(menuBar);

    JToolBar toolBar = new JToolBar();
    toolBar.add(openAction);
    toolBar.add(saveAction);
    // ... more tool-bar buttons
    getContentPane().add(toolBar, BorderLayout.NORTH);

    JPanel panel = new JPanel();
    panel.setLayout(new FlowLayout());
    panel.add(new JButton(openAction));
    panel.add(new JButton(saveAction));
    // ... more buttons
    getContentPane().add(panel, BorderLayout.CENTER);
  }

  class OpenAction extends AbstractAction {
    public OpenAction() {
      putValue(Action.NAME, "Open");
      putValue(Action.SMALL_ICON, new ImageIcon("open16.gif"));
      putValue(Action.MNEMONIC_KEY, new Integer('P'));
      putValue(Action.SHORT_DESCRIPTION, "open file");
      putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(
               KeyEvent.VK_O, InputEvent.CTRL_MASK));
    }
    public void actionPerformed(ActionEvent e) {
      System.out.println(this);
      // ... do something
    }
  }

  class SaveAction extends AbstractAction {
    public SaveAction() {
      putValue(Action.NAME, "Save");
      putValue(Action.SMALL_ICON, new ImageIcon("save16.gif"));
      putValue(Action.MNEMONIC_KEY, new Integer('A'));
      putValue(Action.SHORT_DESCRIPTION, "save file");
      putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(
               KeyEvent.VK_S, InputEvent.CTRL_MASK));
    }
    public void actionPerformed(ActionEvent e) {
      System.out.println(this);
      // ... do something
    }
  }

  // ...more Action classes
}
//--end example------------------------------------------------

You can also write a generic action listener which will invoke a method
on an object:

public class GenericActionListener implements ActionListener {

   protected Method method;
   protected Object object;

   public GenericActionListener(Object object, String methodName) {
       this.object = object;
       try {
           method = object.getClass().getMethod(methodName, null);
       } catch (NoSuchMethodException e) {
           e.printStackTrace();
       }
   }

   // this invokes the method
   public void actionPerformed(ActionEvent e) {
       try {
           method.invoke(object, null);
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       }
   }
}

So, if you have a controller class (say, GUIController), create methods
like "save", "open", "close", etc. in it:

public class GUIController {
   ...
   public void save() {
       ...
   }
   ...
}

Then, for your buttons, simply do this:

// assuming you have a variable for the GUIController called
"guiController"
// (or you can use "this" if your GUI is itself the controller
JButton saveButton = new JButton(...);
saveButton.addActionListener(new GenericActionListener(guiController,
"save"));

When the button is clicked, the method guiController.save() will be
invoked. It's a nice way to keep your code clean, IMO.

You can also extend GenericActionListener to use methods that have
arguments. I'm just showing the bare bones.

- Natasha -