Detailed explanation of Java's method of handling button click events

The following editor will bring you a method of handling button click events in Java. The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.

Different event sources can generate different types of events. For example, a button can send an ActionEvent object, and a window can send a WindowEvent object.

Overview of the AWT time processing mechanism:

1. The listener object is an object that implements a specific An instance of the listener interface class.

#2. The event source is an object that can register listener objects and send event objects.

#3. When an event occurs, the event source passes the event object to all registered listeners.

#4. The listener object will use the information in the event object to decide how to respond to the event.

Here is an example of a listener:

##

ActionListener listener = ...;
JButton button = new JButton("OK");
button.addActionListener(listener);

Now, whenever the button produces a " Action event", the listener object will be notified. For buttons, as we think of it, the action event is clicking the button.

In order to implement the ActionListener interface, the listener class must have a method called actionPerformed, which receives an ActionEvent object parameter.

class MyListener implements ActionListener
{
 ...;
 public void actionPerformed(ActionEvent event)
 {
   //reaction to button click goes here
 }
}

As long as the user clicks the button, the JButton object will create an ActionEvent object, and then call listener.actionPerformed(event) to pass the event object. Multiple listener objects can be added to an event source like a button. In this way, whenever the user clicks the button, the button will call the actionPerformed method of all listeners.

Example: Processing button click events

In order to deepen the understanding of the event delegation model, let’s take a simple example of responding to a button click event. Explain the details you need to know. In this example, you want to place three buttons in a panel and add three listener objects to act as action listeners for the buttons.

In this case, as long as the user clicks any button on the panel, the related listener object will receive an ActionEvent object, which indicates that a button has been clicked. In the sample program, the listener object changes the background color of the panel.

Before demonstrating how to listen to button click events, we first need to explain how to create buttons and how to add them to the panel.

A button can be created by specifying a label string, an icon, or both in the button constructor. Here are two examples:

JButton yellowButton = new JButton("Yellow");
JButton blueButton = new JButton(new ImageIcon("blue-ball.gif"));

To add a button to a panel, you need to call the add method:

JButton yellowButton = new JButton("Yellow");
JButton blueButton = new JButton("Blue");
JButton redButton = new JButton("Red");

buttonPanel.add(yellowButton);
buttonPanel.add(blueButton);
buttonPanel.add(redButton);

This is it , now that you know how to add buttons to the panel, you need to add code that allows the panel to listen to these buttons. This requires a class that implements the ActionListener interface. As mentioned before, an actionPerformed method should be included with the signature:

public void actionPerformed(ActionEvent event)

When the button is clicked, you want to set the background color of the panel to the specified color. This color is stored in the listener class:

class ColorAction implements ActionListener
{
  public ColorAction(Color c)
  {
   backgroundColor = c;
  }
  public void actionPerformed(actionEvent event)
  {
   //set panel background color
   }
   private Color backgroundColor;
}

Then, construct an object for each color and set these objects as button listeners.

ColorAction yelloAction = new ColorAction(Color.YELLOW);
ColorAction blueAction = new ColorAction(Color.BLUE);
ColorAction redAction = new ColorAction(Color.RED);

yellowButton.addActionListener(yellowAction);
blueButton.addActionListener(blueAction);
redButton.addActionListener(redAction);

For example, if a user clicks on a button labeled "Yellow", the actionPerformed method of the yellowAction object will be called. The backgroundColor instance field of this object is set to Color.YELLOW. Now set the background color of the panel to yellow.

There is another issue that needs to be considered. ColorAction objects cannot access buttonpanel variables. This problem can be solved in two ways. One is to store the panel in the ColorAction object and set it in the constructor of ColorAction; the other is to make ColorAction an inner class of the ButtonPanel class, so that its methods automatically have access to the external panel.

The following explains how to place the ColorAction class within the ButtonFrame class.

class ButtonFrame extends JFrame
{
 ...
 private class ColorAction implents ActionListener
 {
  ...
  public void actionPerformed(ActionEvent event)
  {
    buttonPanel.setBackground(backgroundColor);
  }
  private Color backgroundColor;
  }
  private Jpanel buttonPanel; 
}

The above is the detailed content of Detailed explanation of Java's method of handling button click events. For more information, please follow other related articles on the PHP Chinese website!