Java common event response method instance summary

This example summarizes the common event-response methods in Java, including container class listeners, listener classes, AbstractAction, reflection, and so on. For your reference. Specific methods are as follows:

First of all, In the Java graphical user interface, the steps required to process events are :

1. Create a component (control) that accepts the response
2. Implement relevant event monitoring interface
3. Register the action listener of the event source
4. Event handling when the event is triggered

The corresponding event response can be made in the following centralized manner.

1. Container monitoring  
 
Effect: click the three buttons in the form to achieve the corresponding corresponding time.  
 

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 
 
//When you declare a class, add "implements ActionListener" to implement the interface to listen to, separated by commas if you want to listen to multiple ways of listening
//Such as "implements ActionListener, KeyListener"
 
class ButtonListener extends JFrame implements ActionListener{ 
 JButton ok, cancel,exit; //Create the component that accepts the response, which is three buttons
 public ButtonListener(String title){ 
 super(title); 
 this.setLayout(new FlowLayout()); 
 ok = new JButton(" determine "); 
 cancel = new JButton(" return "); 
 exit = new JButton(" exit "); 
//The following three statements register listeners for the button
 ok.addActionListener(this);   
 cancel.addActionListener(this); 
 exit.addActionListener(this); 
 getContentPane().add(ok); 
 getContentPane().add(cancel); 
 getContentPane().add(exit); 
} 
 
//Completes event handling when an event is triggered
 public void actionPerformed(ActionEvent e){ 
   if(e.getSource()==ok) 
    System.out.println(" determine "); 
   if(e.getSource()==cancel) 
    System.out.println(" return "); 
   if(e.getSource()==exit) 
     System.exit(0);; 
 } 
 
 public static void main(String args[]) { 
   ButtonListener pd=new ButtonListener("ActionEvent Demo"); 
   pd.setSize(250,100); 
  pd.setVisible(true); 
 } 
} 
 

Ii. Implementation of monitoring type  
 
Effect: click the three buttons in the form to achieve the corresponding corresponding time.  

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 
 
class ButtonListener1 extends JFrame { //There is no listening
 JButton ok, cancel,exit; 
 public ButtonListener1(String title){ 
  super(title); 
  this.setLayout(new FlowLayout()); 
  ok = new JButton(" determine "); 
  cancel = new JButton(" return "); 
  exit = new JButton(" exit "); 
  ok.addActionListener(new MyListener()); 
  cancel.addActionListener(new MyListener());; 
  exit.addActionListener(new MyListener());; 
  getContentPane().add(ok); 
  getContentPane().add(cancel); 
  getContentPane().add(exit); 
 } 
 
 public static void main(String args[]) { 
   ButtonListener pd=new ButtonListener("ActionEvent Demo"); 
   pd.setSize(250,100); 
  pd.setVisible(true); 
 } 
} 
  //Monitor action event
class MyListener implements ActionListener{ 
  public void actionPerformed(ActionEvent e){ 
   if(e.getActionCommand()==" determine ") 
    System.out.println(" determine "); 
   if(e.getActionCommand()==" return ") 
    System.out.println(" return "); 
   if(e.getActionCommand()==" exit ") 
     System.exit(0);; 
  } 
}

Use the AbstractAction class to implement listening

Effect: click the menu to respond

import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import javax.swing.AbstractAction; 
import javax.swing.Action; 
import javax.swing.JFrame; 
import javax.swing.JMenu; 
import javax.swing.JMenuBar; 
import javax.swing.JMenuItem; 
import javax.swing.JOptionPane; 
 
//For this class of subclass AbstractAction, you must implement the actionPerformed () method.
class AbstractEvent extends AbstractAction{ 
  //private static final long serialVersionUID = 1L; 
  AbstractEvent(){ 
  } 
  public void actionPerformed(ActionEvent e){ 
    //A confirmation dialog box pops up
    if (e.getActionCommand()=="open"){ 
      JOptionPane.showMessageDialog(null, " Open the "); 
    }else if (e.getActionCommand()=="close"){ 
      JOptionPane.showMessageDialog(null, " Shut down "); 
    }else if (e.getActionCommand()=="run"){ 
      JOptionPane.showMessageDialog(null, " run "); 
    }else if (e.getActionCommand()=="stop"){ 
      JOptionPane.showMessageDialog(null, " stop "); 
    } 
  } 
} 
public class TestAbstractEvent { 
  private static JMenuBar menubar; 
  private static JFrame frame; 
   
  //The concrete handler for specifying a MenuEvent is done by the AbstractEvent class.
  final Action MenuEvent=new AbstractEvent(); 
  public TestAbstractEvent(){ 
    frame=new JFrame("menu"); 
    frame.getContentPane().setLayout(new BorderLayout()); 
    menubar=new JMenuBar(); 
    JMenu menuFile=new JMenu("file"); 
     
    //Instantiate a menu item and add listening for openAction,
    JMenuItem menuItemopen=new JMenuItem("open"); 
    menuItemopen.addActionListener(MenuEvent); 
    JMenuItem menuItemclose=new JMenuItem("close"); 
    menuItemclose.addActionListener(MenuEvent); 
    menuFile.add(menuItemopen); 
    menuFile.add(menuItemclose); 
    JMenu menuTool=new JMenu("tool"); 
    JMenuItem menuItemrun=new JMenuItem("run"); 
    menuItemrun.addActionListener(MenuEvent); 
    JMenuItem menuItemstop=new JMenuItem("stop"); 
    menuItemstop.addActionListener(MenuEvent); 
    menuTool.add(menuItemrun); 
    menuTool.add(menuItemstop); 
    menubar.add(menuFile); 
    menubar.add(menuTool); 
    menubar.setVisible(true); 
    frame.add(menubar,BorderLayout.NORTH); 
    frame.setSize(400,200); 
    frame.setVisible(true); 
  } 
  public static void main(String[] args){ 
    new TestAbstractEvent(); 
  } 
} 

AbstractAction class + reflection method  
 
Effect: click the three buttons in the toolbar, and by the name of the button, the reflection gets the same class implementation response as the name of the button.  

import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import javax.swing.*; 
 
class ViewAction extends AbstractAction{ 
  private String ActionName=""; 
  //private JFrame frame=null; 
  private Action action=null; 
  public ViewAction(){ 
  } 
  public ViewAction(String ActionName){ 
    this.ActionName=ActionName; 
    //this.frame=frame; 
  } 
  @Override 
  public void actionPerformed(ActionEvent e) { 
    Action action=getAction(this.ActionName); 
    action.execute(); 
  } 
  private Action getAction(String ActionName){ 
    try{ 
      if (this.action==null){ 
        Action action=(Action)Class.forName(ActionName).newInstance(); 
        this.action=action; 
      } 
      return this.action; 
    }catch(Exception e){ 
    return null; 
    } 
  } 
} 
public class TestAE extends JFrame { 
  public JToolBar bar=new JToolBar(); 
  String buttonName[]={"b1","b2","b3"}; 
  public TestAE(){ 
    super(" The event "); 
    for (int i=0;i<buttonName.length;i++){ 
      ViewAction action=new ViewAction(buttonName[i]); 
      JButton button=new JButton(buttonName[i]); 
      button.addActionListener(action); 
      bar.add(button); 
    } 
    this.getContentPane().add(bar,BorderLayout.NORTH); 
    this.setSize(300, 200); 
    this.setLocationRelativeTo(null); 
    this.setVisible(true); 
  } 
  public static void main(String [] args){ 
    new TestAE(); 
  } 
} 
interface Action{ 
  void execute(); 
} 
class b1 implements Action{ 
  public void execute(){ 
    JOptionPane.showMessageDialog(null, " Click on the  b1"); 
  } 
} 
class b2 implements Action{ 
  public void execute(){ 
    JOptionPane.showMessageDialog(null, " Click on the  b2"); 
  } 
} 
class b3 implements Action{ 
  public void execute(){ 
    JOptionPane.showMessageDialog(null, " Click on the  b3"); 
  } 
}

The above example is well annotated and should be easy to understand. Hopefully the examples described in this article will be helpful.