【Swing】 事件处理+actionlistener

Swing是目前Java中不可缺少的窗口工具组，是用户建立图形化用户界面（GUI）程序的强大工具。Java Swing组件自动产生各种事件来响应用户行为。如当用户点击按钮或选择菜单项目时，Swing组件会产生一个ActionEvent。Swing组件会产生许多事件，如ActionEvents,ChangeEvents,ItemEvents等，来响应用户的鼠标点击行为，列表框中值的改变，计时器的开始计时等行为。在Java Swing编程中，通过注册监听器，我们可以监听事件源产生的事件，从而在事件处理程序中处理我们所需要处理的用户行为。 

Java Swing中处理各组件事件的一般步骤是： 

1．  新建一个组件（如JButton）。 

2．  将该组件添加到相应的面板（如JPanel）。 

3．  注册监听器以监听事件源产生的事件（如通过ActionListener来响应用户点击按钮）。 

4．  定义处理事件的方法（如在ActionListener中的actionPerformed中定义相应方法）。 

以上步骤我们可以用多种方法实现。但人们通常用二种方法。第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件；第二种方法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。 

三个事例：

package lzm;

/* 
 * Simple1.java - 处理事件的第一种方法 
 *    在这个例子中，利用一个ActionListener来监听事件源产生的事件 
 *    用一些if语句来决定是哪个事件源，并返回相应的响应消息
 *    步骤：
 *    第一步：内部类继承ActionListener
 *    第二步：将component添加到内部类对象中 button1.addActionListener(ourListener);
 */

import java.awt.event.*;

import javax.swing.*;

public class Simple1 {
	private static JFrame frame; // 定义为静态变量以便main使用
	private static JPanel myPanel; // 该面板用来放置按钮组件
	private JButton button1; // 这里定义按钮组件
	private JButton button2; // 以便让ActionListener使用

	public Simple1() // 构造器, 建立图形界面
	{
		// 新建面板
		myPanel = new JPanel();
		// 新建按钮
		button1 = new JButton("按钮1");
		button2 = new JButton("按钮2");
		// 添加按钮到面板
		myPanel.add(button1);
		myPanel.add(button2);

		// 在建立监听器以后，记得要将相应的元素添加到ActionListener中
		SimpleListener ourListener = new SimpleListener();
		button1.addActionListener(ourListener);
		button2.addActionListener(ourListener);

	}

	
	private class SimpleListener implements ActionListener {
		/*
		 * 利用该内部类来监听所有事件源产生的事件 便于处理事件代码模块化
		 */
		@Override
		public void actionPerformed(ActionEvent e) {
			//两种获取事件源的方法：getActionCommand、getSource.注意两者的返回类型一个是String，也就是
			//事件源的名字，而另外一个是返回事件源的对象 object
			
			// String:getActionCommand--->Returns the command string associated
			// with this action.
			
		   //object:e.getSource()-->The object on which the Event initially occurred.
			// if (e.getSource() ==button1)

			
			/*
			 * 关于JoptionPane：提示作用。有四种形式：
			 * showConfirmDialog:Asks a confirming question, like yes/no/cancel. 
				showInputDialog:Prompt for some input. 
				showMessageDialog:Tell the user about something that has happened. 
				showOptionDialog:The Grand Unification of the above three.

			 * 
			 * */
			String buttonName = e.getActionCommand();
			if (buttonName.equals("按钮1"))
				JOptionPane.showMessageDialog(frame, "按钮1 被点击");
			else if (buttonName.equals("按钮2"))
				JOptionPane.showMessageDialog(frame, "按钮2 被点击");
			else
				JOptionPane.showMessageDialog(frame, "Unknown event");
		}
	}

	public static void main(String s[]) {
		
		Simple1 gui = new Simple1(); // 新建Simple1组件

		frame = new JFrame("Simple1"); // 新建JFrame
		//将Jpanel对象添加到Jframe中的两种方法
		frame.setContentPane(myPanel);   //frame.getContentPane().add(myPanel);
		
		
		// 处理关闭事件的通常方法
		/*frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});*/
		frame.setLocationRelativeTo(null);// 不会参考任何坐标系。null表示出现在屏幕正中央，否则是左上角
		frame.setResizable(false);// 最大化键
		// Pack():根据窗口里面的布局及组件的preferedSize来确定frame的最佳大小
		//相当于f.setSize(f.getPreferredSize());
		//getPreferredSize():Returns the preferred size of this container.
		frame.pack();
		
		/*
		 * System.exit(0)是退出整个程序，如果有多个窗口，全部都销毁退出。
frame.setDefaultCloseOperation()是设置用户在此窗体上发起 "close" 时默认执行的操作。必须指定以下选项之一： 
DO_NOTHING_ON_CLOSE（在 WindowConstants 中定义）：不执行任何操作；要求程序在已注册的 WindowListener 对象的 windowClosing 方法中处理该操作。 
HIDE_ON_CLOSE（在 WindowConstants 中定义）：调用任意已注册的 WindowListener 对象后自动隐藏该窗体。 
DISPOSE_ON_CLOSE（在 WindowConstants 中定义）：调用任意已注册 WindowListener 的对象后自动隐藏并释放该窗体。 
EXIT_ON_CLOSE（在 JFrame 中定义）：使用 System exit 方法退出应用程序。仅在应用程序中使用。 
默认情况下，该值被设置为 HIDE_ON_CLOSE

也就是说没有设置的话,默认点关闭时只是隐藏窗体,在后台进程中还可以看到，如果有多个窗口，只是销毁调用dispose的窗口，其他窗口仍然存在，整个应用程序还是处于运行状态。
		 * */
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ///设置顶层容器类对象的关闭功能
		frame.setVisible(true);  //设置顶层容器类的可见性
	}
}

package lzm;

/* 
* Simple2.java - 处理事件的第二种方法 
*    在这个例子中，利用匿名内部类来监听每一个事件源产生的事件 
*    避免使用一些if语句来决定是哪个事件源 
*/ 

import java.awt.*; 
import java.awt.event.*; 

import javax.swing.*; 

public class Simple2 
{ 
   private static JFrame frame;   // 定义为静态变量以便main使用 
   private static JPanel myPanel; // 该面板用来放置按钮组件 
   private JButton button1;       // 这里定义按钮组件     
   private JButton button2;       // 以便让ActionListener使用 
   private JButton button3;
   public Simple2()               // 构造器, 建立图形界面 
    { 
       // 新建面板 
       myPanel = new JPanel(); 
       // 新建按钮 
       button1 = new JButton("按钮1");  // 新建按钮1 
       button2 = new JButton("按钮2"); 
       button3 =  new JButton("按钮3");
       // 每一个事件源需要一个监听器 
       // 定义一个匿名内部类来监听事件源产生的事件 
       button1.addActionListener( 
           new ActionListener() 
           { 
               public void actionPerformed(ActionEvent e) 
               { 
                   JOptionPane.showMessageDialog(frame, 
                                          "按钮1 被点击"); 
               } 
           } 
       ); 

       button2.addActionListener( 
           new ActionListener() 
           { 
               public void actionPerformed(ActionEvent e) 
               { 
                   JOptionPane.showMessageDialog(frame, 
                                           "按钮2 被点击"); 
               } 
           } 
       ); 
   button3.addActionListener(new ActionListener() {
	
	@Override
	public void actionPerformed(ActionEvent e) {
		JOptionPane.showMessageDialog(frame, "按钮3被点击");
		
	}
});
       myPanel.add(button1);        // 添加按钮到面板 
       myPanel.add(button2); 
       myPanel.add(button3);
   } 

   public static void main(String s[]) 
   { 
       Simple2 gui = new Simple2(); // 新建Simple2组件 
        
       frame = new JFrame("Simple2");  // 新建JFrame 
       // 处理关闭事件的通常方法 
       frame.addWindowListener(new WindowAdapter() { 
            public void windowClosing(WindowEvent e) 
             {System.exit(0);} }); 
       frame.getContentPane().add(myPanel); 
       frame.pack();                   
       frame.setVisible(true); 
   } 
}

package lzm;

/* 
 * Simple3.java - 处理事件的第三种方法 
 *    For this example, we will use inner member classes to 
 *    在这个例子中，利用一般内部类来监听每个事件源产生的事件 
 *    该方法避免了第二种方法中由于使用匿名内部类而导致的代码混乱 
 *    便于集中处理事件代码 
 *    每一个Hander可以被工具栏或菜单多次使用 
 */ 
import java.awt.*; 
import java.awt.event.*; 

import javax.swing.*; 

public class Simple3 
{ 
    private static JFrame frame;   // 定义为静态变量以便main使用 
    private static JPanel myPanel; // 该面板用来放置按钮组件 
    private JButton button1;       // 这里定义按钮组件     
    private JButton button2;       // 以便让ActionListener使用 
     private JButton button3;  
    // 利用一般内部类来监听每一个事件源产生的事件如(button1, button2) 
    private class Button1Handler implements ActionListener 
    { 
        public void actionPerformed(ActionEvent e) 
        { 
            JOptionPane.showMessageDialog(frame, 
                                         "按钮1 被点击"); 
        } 
    } 
     
    private class Button2Handler implements ActionListener 
    { 
        public void actionPerformed(ActionEvent e) 
        { 
            JOptionPane.showMessageDialog(frame, 
                                         "按钮2 被点击"); 
        } 
    } 
    
    private  class Button3Handler implements ActionListener{

		@Override
		public void actionPerformed(ActionEvent e) {
			JOptionPane.showMessageDialog(frame, "按钮3被点击");
			
		}
    	
    }
     
    public Simple3()                //  // 构造器, 建立图形界面 
    { 
         // 新建面板 
        myPanel = new JPanel(); 
        // 新建按钮 
        button1 = new JButton("按钮1");  // 新建按钮1 
        button2 = new JButton("按钮2"); 
        button3 = new JButton("按钮3"); 

        // 对每一个组件注册监听内部类 
        button1.addActionListener(new Button1Handler()); 
        button2.addActionListener(new Button2Handler()); 
        button3.addActionListener(new Button3Handler());
        myPanel.add(button1);        // 添加按钮到面板 
        myPanel.add(button2); 
        myPanel.add(button3);
    } 

    public static void main(String s[]) 
    { 
        Simple3 gui = new Simple3();  // 新建Simple3组件 

        frame = new JFrame("Simple3");  // 新建JFrame 
        // 处理关闭事件的通常方法         
        frame.addWindowListener(new WindowAdapter() { 
             public void windowClosing(WindowEvent e) 
              {System.exit(0);} }); 

        frame.getContentPane().add(myPanel); 
        frame.pack();                    
        frame.setVisible(true); 
    } 
} 

在这下面添加事件中的定时器类Timer，结合事件有很多用处

package lzm;


import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.Timer;

//Timer类好比是一个定时器，或者说是触发器。典型例子：写某些程序（比如俄罗斯方块）时需要一个定时触发的事件去触发一段程序的执行，此时就要用到Timer。

public class Test extends JFrame implements ActionListener {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private int now_s=0;
      public Test(){
    	  //两个部分
    	  //首先是构造函数，第一个参数时间间隔。第二个是Actionlistener对象。因为这个类本身就已经实现了Actionlistener，所以直接使用this
    	  //void:start--->Starts the Timer, causing it to start sending action events to its listeners.
    	  //所谓送给监听者，其实就是去执行从ActionListener中覆盖的actionPerformed()
    	  new Timer(1000,this).start();
    	  while(true);
      }

	@Override
	public void actionPerformed(ActionEvent e) {
	    System.out.println("now_s="+now_s);
	    now_s++;
	}
	
	public static void main(String[] args){
		new Test();
	}
}