Java GUI编程10---事件处理

桃扇骨 2022-05-22 05:22 256阅读 0赞

# 事件处理 #

之前介绍了`Swing`的一些图形组件，一个图形界面制作完成了，在程序开发中只是完成了起步的工作。要想让一个组件都发挥自己的作用，就必须对所有的组件进行事件处理。

## 事件和监听器 ##

先来了解什么是事件，事件就是表示一个对象的状态发生了变化。例如，每当一个按钮按下时，实际按钮的状态就发生了改变，那么此时就会产生一个事件，而如果需要事件的监听者不断的监听事件的变化，并根据这些事件进行相应的处理。  
在`Swing`编程中，依然使用了最早的`AWT`的事件处理方式，所有的事件类(基本上任意一个组件都有对应的事件)都是`EventObject`类的子类。如下图所示。  
![事件类的继承关系][70]  
`EventObject`类的`JDK`源码：

public class EventObject implements java.io.Serializable { 
        private static final long serialVersionUID = 5516075349620653480L;
        protected transient Object  source;
        public EventObject(Object source) { 
            if (source == null)
                throw new IllegalArgumentException("null source");
    
            this.source = source;
        }
        public Object getSource() { 
            return source;
        }
        public String toString() { 
            return getClass().getName() + "[source=" + source + "]";
        }
    }

在`EventObject` 中定义了三个方法，其中可以通过`getSource()`方法取得发生此事件的源对象。  
**事件监听器：**  
如果没有能够接受和处理事件的对象，图形界面程序生成的一切事件都是无用的，这些事件接收对象被称为事件监听器。所有的事件监听器都是以接口的形式出现的，处理是只需要实现此接口即可。  
整个事件处理的流程如下图所示：

Created with Raphaël 2.2.0事件源处理事件方法是否有监听器处理事件特定事件的处理方法找到注册的事件监听器End放弃事件yesno

下面是一下实例。大部分图形界面的处理类或结构都保存在`java.awt.event`包中。

## 窗体事件 ##

`WindowListener`是专门处理窗体的事件监听接口，一个窗体的所有变换，如窗口打开，关闭等都可以使用`WindowListener`这个接口进行监听。`WindowListener`接口定义的方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>void windowActivated(WindowEvent e)</code></td> 
   <td>将窗口变为活动窗口时触发</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>void windowDeactivated(WindowEvent e)</code></td> 
   <td>将窗体变为不活动窗口是触发</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>void windowClosing(WindowEvent e)</code></td> 
   <td>当窗口正在关闭时触发</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>void windowClosed(WindowEvent e)</code></td> 
   <td>当窗口被关闭了触发</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>void windowIconified(WindowEvent e)</code></td> 
   <td>窗口从正常状态变为最小化状态时触发</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><code>void windowDeiconified(WindowEvent e)</code></td> 
   <td>窗口从最小化状态变为正常状态时触发</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td><code>void windowOpened(WindowEvent e)</code></td> 
   <td>窗口打开是触发</td> 
  </tr> 
 </tbody> 
</table>

**实例：通过实现`WindowListener`接口来监听窗体事件**

import java.awt.event.WindowListener;
    import java.awt.event.WindowEvent;
    import java.awt.Color;
    import javax.swing.JFrame;
    //通过实现事件监听器接口方式来监听事件
    class MyWindowEventHandle implements WindowListener
    { 
    	public void windowActivated(WindowEvent e)
    	{ 
    		System.out.println("windowActivated --> 窗口被选中");
    	}
    	public void windowClosed(WindowEvent e)
    	{ 
    		System.out.println("windowClosed --> 窗口被关闭");
    	}
    	public void windowClosing(WindowEvent e)
    	{ 
    		System.out.println("windowClosing --> 窗口关闭");
    		System.exit(1);//退出程序
    	}
    	public void windowDeactivated(WindowEvent e)
    	{ 
    		System.out.println("windowDeactivated --> 取消窗口选中");
    	}
    	public void windowDeiconified(WindowEvent e)
    	{ 
    		System.out.println("windowDeiconified --> 窗口从最小化恢复");
    	}
    	public void windowIconified(WindowEvent e)
    	{ 
    		System.out.println("windowIconified --> 窗口最小化");
    	}
    	public void windowOpened(WindowEvent e)
    	{ 
    		System.out.println("windowOpened --> 窗口被打开");
    	}
    }
    
    public class MyEventWindowEventJFrame01
    { 
    	public static void main(String args[])
    	{ 
    		JFrame frame = new JFrame("窗体事件处理");
    		//窗体中加入事件监听器
    		frame.addWindowListener(new MyWindowEventHandle()); // 加入事件
    		frame.setSize(300, 150);
    		//设置背景颜色
    		frame.getContentPane().setBackground(Color.PINK);
    		frame.setLocation(300, 200);
    		frame.setVisible(true);
    	}
    }

窗体显示效果：  
![窗体显示效果][70 1]  
控制台输出：

windowActivated --> 窗口被选中
    windowOpened --> 窗口被打开
    windowIconified --> 窗口最小化
    windowDeactivated --> 取消窗口选中
    windowDeiconified --> 窗口从最小化恢复
    windowActivated --> 窗口被选中
    windowDeactivated --> 取消窗口选中
    windowActivated --> 窗口被选中
    windowDeactivated --> 取消窗口选中
    windowClosing --> 窗口关闭

当鼠标移动当窗体上的时候，窗体被选中，当鼠标移出窗体之外的位置时，窗体不被选中。当最小化窗体的时候，触发最小化事件，再次显示点击窗体按钮时，触发从最小化恢复事件，最大化好像没有对应的事件。在上面的窗口关闭事件中写入了`System.exit(1)`语句，这样当关闭窗体时程序结束。关闭按钮起作用。

## 监听适配器 ##

如果现在只需要对关闭窗体的事件进行监听，其他操作我们根本不关心，就没必要通过实现接口的方式来监听事件，因为通过实现接口的方式，我们要实现事件监听接口(`WindowListener`)里面的所有的方法。  
为解决上述问题，引入适配器设计模式，在实现类和接口之间增加一个过渡的抽象来，字节继承抽象类就可以根据自己的需要进行事件方法的覆盖。在整个事件处理中提供了很多的`Adapter`(适配器)类，方便用户进行事件处理的实现。以`WindowAdapter`为例，用户只需要继承`WindowAdapter`类，就可以根据自己的需要覆盖方法，如果现在只关心窗体的关闭事件方法，则只下子类中覆盖`windowClosing()`方法即可。  
实例：通过`WindowAdapter`实现监听

class MyWindowEventHandle1 extends WindowAdapter
    { 
    	public void windowClosing(WindowEvent e)
    	{ 
    		System.out.println("windowClosing --> 窗口关闭");
    		System.exit(1);//退出系统
    	}
    }

而在窗体操作的代码中，直接使用上面的监听器类即可：

JFrame frame = new JFrame("通过适配器监听处理事件");
    // 加入监听器
    frame.addWindowListener(new MyWindowEventHandle1());

完整代码：

package java1.swing.event;
    
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.Color;
    import javax.swing.JFrame;
    
    class MyWindowEventHandle1 extends WindowAdapter
    { 
    	public void windowClosing(WindowEvent e)
    	{ 
    		System.out.println("windowClosing --> 窗口关闭");
    		System.exit(1);
    	}
    }
    
    public class MyEventWindowEventJFrame02
    { 
    	public static void main(String args[])
    	{ 
    		JFrame frame = new JFrame("通过适配器监听处理事件");
    		frame.addWindowListener(new MyWindowEventHandle1()); // 加入事件
    		frame.setSize(300, 150);
    		frame.getContentPane().setBackground(Color.yellow);
    		frame.setLocation(300, 200);
    		frame.setVisible(true);
    	}
    }

运行效果：  
![运行效果][70 2]  
关闭该窗体，控制台输出：

windowClosing --> 窗口关闭

## 使用匿名内部来监听事件—只需使用一次的情况 ##

如果此监听处理只需要操作一次，没有必要将其设置成为一单独的类，此时可以利用匿名内部类来事件的操作。  
实例：使用匿名内部类方式实现事件监听

import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.Color;
    import javax.swing.JFrame;
    public class MyEventWindowEventJFrame03
    { 
    	public static void main(String args[])
    	{ 
    		JFrame frame = new JFrame("使用匿名内部来");
    		// 加入事件
    		frame.addWindowListener(
    		//匿名内部类方式，实现事件监听。
    		new WindowAdapter()
    		{ 
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.out.println("windowClosing --> 窗口关闭");
    				System.exit(1);
    			}
    		}); 
    		frame.setSize(300, 150);
    		frame.getContentPane().setBackground(Color.green);
    		frame.setLocation(300, 200);
    		frame.setVisible(true);
    	}
    }

运行效果：  
![使用匿名内部类实现事件监听处理][70 3]  
点击窗体的关闭按钮，控制输出：

windowClosing --> 窗口关闭

同时程序结束。  
使用适配器操作类，直接编写匿名内部类就可以减少监听类的定义，这是在开发中比较常见的一种方法。

## 动作事件及监听处理 ##

要想让一个按钮变得有意义，就必须使用事件处理。在`Swing`的事件处理中，可以使用`ActionListener`接口处理按钮的动作事件。`ActionListener`接口只定义了一个方法，如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>void actionPerformed(ActionEvent e)</code></td> 
   <td>发生操作时调用。</td> 
  </tr> 
 </tbody> 
</table>

下面使用上面的监听接口监听按钮的单击事件。  
**实例：使用`ActionListener`监听**

运行效果：  
![运行效果1][1]  
如果新的信息然后点击按钮，则可以改变下面标签的内容：  
![点击按钮改变标签的内容][70 4]

以上程序使用类匿名内部类的方式完成时间监听，因为动作事件可能有多个事件源调用，所以为了保险起见，在代码操作之前要添加验证：

//当这个事件是按钮but的时候调用
    if (e.getSource() == but)
    { 
    	//获取文本框中的文字，然后设置到标签中
    	lab.setText(text.getText());
    }

当然这个判断代码是在同一类类中完成的，如果现在换成两个类，则可以通过`instanceof`关键字来判断操作的数据源类型，如下所示。

//判断触发源是否是按钮
    if (e.getSource()instanceof JButton)
    { 
    	//获取文本框中的文字，然后设置到标签中
    	lab.setText(text.getText());
    }

下面实现一个简单的用户登录操作：如果用户输入的用户名为`user`,密码为`admin`，则认为是合法用户，提示登录成功的信息，反之，则提示登录失败的信息，代码如下所示。

import java.awt.event.WindowAdapter;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowEvent;
    import java.awt.event.ActionEvent;
    import java.awt.Color;
    import java.awt.Font;
    import javax.swing.JFrame;
    import javax.swing.JButton;
    import javax.swing.JLabel;
    import javax.swing.JTextField;
    import javax.swing.JPasswordField;
    import javax.swing.JPanel;
    
    class LoginCheck
    { 
    	private String name;
    	private String password;
    	public LoginCheck(String name, String password)
    	{ 
    		this.name = name;
    		this.password = password;
    	}
    
    	public boolean ispass()
    	{ 
    		if ("user".equals(name) && "admin".equals(password))
    		{ 
    			return true;
    		} else
    		{ 
    			return false;
    		}
    	}
    };
    
    class ActionHandle1
    { 
    	private JFrame frame = new JFrame("简单登录模式");
    	private JButton submit = new JButton("登陆");
    	private JButton reset = new JButton("重置");
    	private JLabel nameLab = new JLabel("用户名：");
    	private JLabel passLab = new JLabel("密 码：");
    	private JLabel infoLab = new JLabel("请输入用户名和密码");
    	private JTextField nameText = new JTextField(10);
    	private JPasswordField passText = new JPasswordField();
    	private JPanel pan = new JPanel();
    	public ActionHandle1()
    	{ 
    		// 设置字体
    		Font fnt = new Font("Serief", Font.ITALIC + Font.BOLD, 14);
    		// 标签设置字体样式
    		infoLab.setFont(fnt); // 设置标签的显示文字
    		submit.setFont(fnt); 
    		reset.setFont(fnt); 
    		nameLab.setFont(fnt); 
    		passLab.setFont(fnt); 
    		// 监听登录按钮事件
    		submit.addActionListener(new ActionListener()
    		{ 
    			public void actionPerformed(ActionEvent e)
    			{ 
    				if (e.getSource() == submit)
    				{ 
    					// 获取名字框的文本
    					String tname = nameText.getText();
    					// 获取密码框的文本
    					String tpass = new String(passText.getPassword());
    					// 检查用户名和密码
    					LoginCheck log = new LoginCheck(tname, tpass);
    					if (log.ispass())
    					{ 
    						// 设置提示标签
    						infoLab.setText("登陆成功，欢迎光临！");
    					} else
    					{ 
    						infoLab.setText("登陆失败，错误的用户名或密码！");
    					}
    				}
    			}
    		});
    		// 设置重置按钮事件处理
    		reset.addActionListener(new ActionListener()
    		{ 
    			public void actionPerformed(ActionEvent e)
    			{ 
    				if (e.getSource() == reset)
    				{ 
    					// 用户名和密码框置空
    					nameText.setText("");
    					passText.setText("");
    					infoLab.setText("请输入用户名和密码");
    				}
    			}
    		});
    		// 关闭窗口事件
    		frame.addWindowListener(new WindowAdapter()
    		{ 
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.exit(1);
    			}
    		}); // 加入事件
    		// 不适用布局管理器
    		frame.setLayout(null);
    		// 设置第一行的三个组件的位置和大小
    		nameLab.setBounds(  5, 5, 60, 20);
    		nameText.setBounds(65, 5, 100, 20);
    		submit.setBounds( 170, 5, 80, 20);
    		// 设置第2行的三个组件的位置和大小
    		passLab.setBounds(  5, 30, 60, 20);
    		passText.setBounds(65, 30, 100, 20);
    		reset.setBounds(  170, 30, 80, 20);
    		// 设置提示标签的位置和大小
    		infoLab.setBounds(5, 65, 220, 30);
    		// 添加组件
    		// 添加第一行
    		frame.add(nameLab);
    		frame.add(nameText);
    		frame.add(submit);
    		// 添加第二行
    		frame.add(passLab);
    		frame.add(passText);
    		frame.add(reset);
    		// 添加第三行
    		frame.add(infoLab);
    		frame.setSize(280, 130);
    		// 设置窗体背景颜色
    		frame.getContentPane().setBackground(Color.PINK);
    		frame.setLocation(300, 200);
    		frame.setVisible(true);
    
    	}
    }
    
    public class MyActionEventDemo03
    { 
    	public static void main(String args[])
    	{ 
    		new ActionHandle1();
    	}
    }

运行结果：  
![初始界面][70 5]  
输入错误的用户名，或秘密，会显示登录失败：  
![登录失败][70 6]  
点击重置会清空用户名和密码框。  
![点击重置][70 7]  
正确输入用户名`user`和密码`admin`，则提示成功登录。  
![登录成功][70 8]  
以上程序在窗体上使用了一个文本框和一个密码框接收输入的用户名和密码，当单击按钮时会触发`ActionEvent`事件，并判断发生此事件的是哪个按钮，如果是**登录**按钮触发的则从文本框中提取出内容并通过`LoginCheck`类进行用户名和密码的验证。如果是**重置**按钮这将用户名和密码框的内容清空。

## 键盘事件及监听处理 ##

在`Swing`的事件处理中也可以对键盘的操作进行监听，直接使用`KeyListener`接口即可。此接口定义了如下表所示的方法。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>void keyPressed(KeyEvent e)</td> 
   <td>按下键盘是调用此方法。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>void keyReleased(KeyEvent e)</td> 
   <td>松开键盘调用此方法。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>void keyTyped(KeyEvent e)</td> 
   <td>按下<strong>某个按键</strong>时调用此方法。</td> 
  </tr> 
 </tbody> 
</table>

如果想取得键盘输入的内容，则可以通过`KeyEvent`取得。此类的常用方法如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public char getKeyChar()</code></td> 
   <td>返回输入的字符，该方法只对于<code>KeyTyped</code>有意义。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public int getKeyCode()</code></td> 
   <td>返回输入的字符的整数<code>keyCode</code>(键码)</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public static String getKeyText(int keyCode)</code></td> 
   <td>返回<code>keyCode</code>(键码)对应的字符，如 “<code>HOME</code>”、"<code>F1</code>" 或 “<code>A</code>”，"<code>Enter</code>"等。</td> 
  </tr> 
 </tbody> 
</table>

**实例：实现键盘监听**

package java1.swing.event;
    
    import java.awt.event.WindowAdapter;
    import java.awt.event.KeyListener;
    import java.awt.event.WindowEvent;
    import java.awt.event.KeyEvent;
    import javax.swing.JFrame;
    import javax.swing.JTextArea;
    import javax.swing.JScrollPane;
    
    //
    class MyKeyHandle extends JFrame implements KeyListener
    { 
    	//文本域
    	private JTextArea text = new JTextArea();
    	public MyKeyHandle()
    	{ 
    		//设置窗体标题
    		super.setTitle("监听键盘事件");
    		//实例化一个带有滚动条的面板
    		JScrollPane scr = new JScrollPane(text);
    		//设置滚动条面板大小
    		scr.setBounds(5, 5, 300, 200);
    		//窗体中添加滚动条面板
    		super.add(scr);
    		//文本域中监听键盘事件，指定监听器为当前对象
    		text.addKeyListener(this);
    		//窗体监听窗体事件
    		super.addWindowListener(new WindowAdapter()
    		{ 
    			//如果关闭窗体就退出程序
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.exit(1);
    			}
    		}); 
    		//设置窗体大小
    		super.setSize(310, 210);
    		//设置窗体可见
    		super.setVisible(true);
    	}
    	//按下键盘
    	public void keyPressed(KeyEvent e)
    	{ 
    		text.append("键盘“" + KeyEvent.getKeyText(e.getKeyCode()) + "”键按下\n");
    	}
    	//松开键盘
    	public void keyReleased(KeyEvent e)
    	{ 
    		text.append("键盘“" + KeyEvent.getKeyText(e.getKeyCode()) + "”键松开\n");
    	}
    	//按下哪个键盘
    	public void keyTyped(KeyEvent e)
    	{ 
    		text.append("输入的内容是：" + e.getKeyChar() + "\n");
    	}
    }
    public class MyKeyEventDemo01
    { 
    	public static void main(String args[])
    	{ 
    		new MyKeyHandle();
    	}
    }

运行结果：  
![监听键盘事件][70 9]  
以上程序中针对每个键盘的操作都会进行监听，并且在取得键盘信息时最好使用`KeyEvent`类的静态方法`getKeyEventText()`完成。  
在上面的程序中，`MyKeyHandle`实现了`KeyListener`接口，所以`MyKeyHandle`也就是监听操作类，这样当`JTextArea`增加事件时可以直接使用了`this`关键字。

//文本域中监听键盘事件，指定监听器为当前对象
    text.addKeyListener(this);

在键盘监听中也可以使用`KeyAdapter`适配器完成键盘事件的监听，如下所示。

**实例：使用KeyAdapter**  
监听键盘的上下左右箭头

import java.awt.event.WindowAdapter;
    import java.awt.event.KeyAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.event.KeyEvent;
    import javax.swing.JFrame;
    import javax.swing.JTextArea;
    import javax.swing.JScrollPane;
    
    class MyKeyHandle1 extends JFrame
    {
    	private JTextArea text = new JTextArea();
    	public MyKeyHandle1()
    	{
    		// 设置窗体标题
    		super.setTitle("监听键盘事件");
    		// 实例化带滚动条的面板，面板中放入一个文本域
    		JScrollPane scr = new JScrollPane(text);
    		// 设置面板的位置和宽度高度
    		scr.setBounds(5, 5, 300, 200);
    		// 窗体中加入滚动条面板
    		super.add(scr);
    		// 文本域监听键盘事件，使用适配器，匿名内部类实现
    		text.addKeyListener(new KeyAdapter()
    		{
    			// 按下键盘
    			public void keyPressed(KeyEvent e)
    			{
    				switch (e.getKeyCode())
    				{
    					case KeyEvent.VK_DOWN :
    						text.append("箭头向下\n");
    						break;
    					case KeyEvent.VK_UP :
    						text.append("箭头向上\n");
    						break;
    					case KeyEvent.VK_LEFT :
    						text.append("箭头向左\n");
    						break;
    					case KeyEvent.VK_RIGHT :
    						text.append("箭头向右\n");
    						break;
    					default :
    				}
    			}
    		});
    		// 窗体监听窗体关闭事件
    		super.addWindowListener(new WindowAdapter()
    		{
    			public void windowClosing(WindowEvent e)
    			{
    				System.exit(1);// 关闭窗体时结束程序
    			}
    		});
    		// 设置窗体大小
    		super.setSize(400, 210);
    		super.setVisible(true);
    	}
    
    }
    
    public class MyKeyEventDemo02
    {
    	public static void main(String args[])
    	{
    		new MyKeyHandle1();
    	}
    }

运行效果：  
![监听上下左右健][70 10]  
实例3：监听键盘事件

package java1.swing.event;
    import java.awt.event.WindowAdapter;
    import java.awt.event.KeyAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.event.KeyEvent;
    import javax.swing.JFrame;
    import javax.swing.JTextArea;
    import javax.swing.JScrollPane;
    
    class MyKeyHandle3 extends JFrame
    {
    	private JTextArea text = new JTextArea();
    	public MyKeyHandle3()
    	{
    		super.setTitle("监听键盘事件");
    		JScrollPane scr = new JScrollPane(text);
    		scr.setBounds(5, 5, 300, 200);
    		super.add(scr);
    		text.addKeyListener(new KeyAdapter()
    		{
    			public void keyTyped(KeyEvent e)
    			{
    				text.append("\n输入的内容是：" + e.getKeyChar());
    			}
    		});
    		super.addWindowListener(new WindowAdapter()
    		{
    			public void windowClosing(WindowEvent e)
    			{
    				System.exit(1);
    			}
    		}); // 加入事件
    		super.setSize(310, 210);
    		super.setVisible(true);
    	}
    
    };
    
    public class MyKeyEventDemo03
    {
    	public static void main(String args[])
    	{
    		new MyKeyHandle3();
    	}
    };

运行结果：  
![运行结果][70 11]  
你可能发现了上面按下一个键，文本域中却显示里两个字符，其实，这里有一个字符是

public void keyTyped(KeyEvent e)
    {
    	text.append("\n输入的内容是：" + e.getKeyChar());
    }

中的`e.getKeyChar()`输入的，剩下的一个字符是输入法输入的。所以一般不要把字符输入的字符打印到文本域中，这样会然人以为程序蹦了。

## 6、鼠标点击事件及监听处理 ##

如果想对一个鼠标的操作进行监听，如鼠标按下，松开等，则可以使用`MouseListener`接口，此接口定了了如下表所示的方法。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>void mouseClicked(MouseEvent e)</code></td> 
   <td>鼠标按键在组件上<strong>单击</strong>（按下并释放）<strong>时调用</strong>。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>void mousePressed(MouseEvent e)</code></td> 
   <td>鼠标按键在组件上<strong>按下时调用</strong>。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>void mouseReleased(MouseEvent e)</code></td> 
   <td>鼠标按钮在组件上<strong>释放时调用</strong>。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>void mouseEntered(MouseEvent e)</code></td> 
   <td>鼠标<strong>进入到组件上时调用</strong>。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>void mouseExited(MouseEvent e)</code></td> 
   <td>鼠标离开组件时调用。</td> 
  </tr> 
 </tbody> 
</table>

在每个事件触发后，都会调用`MouseEvent`事件，此事件可以的得到鼠标的相关操作。`MouseEvent`类的常用方法以及常量如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>常量</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public static int BUTTON1</code></td> 
   <td>指示鼠标按键 #1(表示鼠标左键)；由 <code>getButton()</code> 使用。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public static int BUTTON2</code></td> 
   <td>指示鼠标按键 #2(表示鼠标滚轮)；由 <code>getButton()</code> 使用。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public static int BUTTON3</code></td> 
   <td>指示鼠标按键 #3(表示鼠标右键)；由 <code>getButton()</code> 使用。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>public int getButton()</code></td> 
   <td>以数字形式返回按下的鼠标键</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>public int getClickCount()</code></td> 
   <td>返回与此事件关联的<strong>鼠标单击次数</strong>。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><code>public static String getMouseModifiersText(int modifiers)</code></td> 
   <td>以字符串形式返回鼠标按下的键的信息</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><code>int getX()</code></td> 
   <td>返回事件相对于源组件的水平 x 坐标。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><code>int getY()</code></td> 
   <td>返回事件相对于源组件的垂直 y 坐标。</td> 
  </tr> 
 </tbody> 
</table>

实例：实现鼠标监听

import java.awt.event.WindowAdapter;
    import java.awt.event.MouseListener;
    import java.awt.event.WindowEvent;
    import java.awt.Color;
    import java.awt.event.MouseEvent;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JTextArea;
    import javax.swing.JScrollPane;
    
    class MyMouseHandle extends JFrame implements MouseListener
    { 
    	//创建
    // private JTextArea text = new JTextArea();
    // private JButton text = new JButton();
    	private JLabel jLabelText = new JLabel("标签");
    	//创建文本域2--用于打印状态
    	private JTextArea showText = new JTextArea();
    	//实例化鼠标监听器
    	public MyMouseHandle()
    	{ 
    		super.setTitle("测试鼠标事件");
    		JScrollPane scr = new JScrollPane(showText);
    // super.setLayout(new GridLayout(2,1));
    		//不适用布局管理器
    		super.setLayout(null);
    		//此句是重点，设置背景颜色必须先将它设置为不透明的，因为默认是透明的
    		//设置标签不透明
    		jLabelText.setOpaque(true);  
    		//设置标签颜色
    		jLabelText.setBackground(Color.pink);
    		//设置标签大小
    		jLabelText.setBounds(0, 0, 50,30);
    		//设置标签的文字颜色
    		jLabelText.setForeground(Color.BLUE);//可以直接设置文字颜色
    		
    		
    		scr.setBounds(0, 30, 300, 200);
    		super.add(jLabelText);
    		super.add(scr);
    		//处理事件的程序在本类中
    		jLabelText.addMouseListener(this);
    		//窗体监听窗体关闭事件
    		super.addWindowListener(new WindowAdapter()
    		{ 
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.exit(1);
    			}
    		}); // 加入事件
    		super.setSize(310, 210);
    		super.setVisible(true);
    	}
    	//实现鼠标单击
    	public void mouseClicked(MouseEvent e)
    	{ 
    		int c = e.getButton();
    		String mouseInfo = null;
    		if (c == MouseEvent.BUTTON1)
    		{ 
    			mouseInfo = "左键";
    		}
    		if (c == MouseEvent.BUTTON3)
    		{ 
    			mouseInfo = "右键";
    		}
    		if (c == MouseEvent.BUTTON2)
    		{ 
    			mouseInfo = "滚轮";
    		}
    		showText.append("鼠标单击：" + mouseInfo + "\n");
    	}
    	//鼠标进入组件
    	public void mouseEntered(MouseEvent e)
    	{ 
    		showText.append("鼠标进入组件。\n");
    	}
    	//鼠标离开组件
    	public void mouseExited(MouseEvent e)
    	{ 
    		showText.append("鼠标离开组件。\n");
    	}
    	//鼠标按下
    	public void mousePressed(MouseEvent e)
    	{ 
    		showText.append("鼠标按下。\n");
    	}
    	//鼠标松开
    	public void mouseReleased(MouseEvent e)
    	{ 
    		showText.append("鼠标松开。\n");
    	}
    
    }
    
    public class MyMouseEventDemo01
    { 
    	public static void main(String args[])
    	{ 
    		new MyMouseHandle();
    	}
    }

运行结果：  
![测试鼠标事件][70 12]  
文本域中显示的文字：

鼠标进入组件。
    鼠标离开组件。
    鼠标进入组件。
    鼠标按下。
    鼠标松开。
    鼠标单击：左键
    鼠标按下。
    鼠标松开。
    鼠标单击：右键
    鼠标按下。
    鼠标松开。
    鼠标单击：滚轮
    鼠标离开组件。

在上面的例子总，只要鼠标进入或者离开组件，都会有鼠标事件触发。还可以通过单击事件取得鼠标哪个按键(左键，右键，还是滚轮)按下。  
上面的例子中实现了`MouseListener`接口，这样必须在实现类中实现`MouseListener`中的五个抽象方法，为了简化起见，也可以直接使用`MouseAdapter`完成对鼠标指定事件的监听。  
**实例：通过MouseAdapter完成对指定鼠标操作的监听**

import java.awt.event.WindowAdapter;
    import java.awt.Color;
    import java.awt.event.MouseAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.event.MouseEvent;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JTextArea;
    import javax.swing.JScrollPane;
    
    class MyMouseHandle1 extends JFrame
    { 
    	
    	//创建一个文本域
    	private JLabel jLabletext = new JLabel("我是标签");
    	private JTextArea text = new JTextArea();
    	public MyMouseHandle1()
    	{ 
    		super.setTitle("使用适配器监听鼠标事件");
    		//创建带滚条的面板
    		text.setEditable(false);
    		JScrollPane scr = new JScrollPane(text);
    		//设置面板的坐标和款款地高度
    		//不适用布局管理器
    		super.setLayout(null);
    		//设置标签不透明
    		jLabletext.setOpaque(true);
    		//设置标签的背景颜色
    		jLabletext.setBackground(Color.pink);
    		//设置标签的字体
    		jLabletext.setForeground(Color.blue);
    		jLabletext.setBounds(5,5, 80, 40);
    		//加入标签
    		super.add(jLabletext);
    		scr.setBounds(5,45, 300, 200);
    		super.add(scr);
    		//使用适配器实现鼠标事件的监听
    		jLabletext.addMouseListener(new MouseAdapter()
    		{ 
    			//只监听鼠标单击事件
    			public void mouseClicked(MouseEvent e)
    			{ 
    				//获取按下的是哪个按键的整数编码
    				int c = e.getButton();
    				String mouseInfo = null;
    				//如果按下的按键是左键
    				if (c == MouseEvent.BUTTON1)
    				{ 
    					mouseInfo = "左键";
    				}
    				if (c == MouseEvent.BUTTON3)
    				{ 
    					mouseInfo = "右键";
    				}
    				if (c == MouseEvent.BUTTON2)
    				{ 
    					mouseInfo = "滚轴";
    				}
    				//添加到文本域中
    				text.append("鼠标单击：" + mouseInfo + "\n");
    			}
    		});
    		//面板监听窗体关闭事件
    		super.addWindowListener(new WindowAdapter()
    		{ 
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.exit(1);
    			}
    		}); 
    		//设置窗体大小设置窗体可见
    		super.setSize(310, 210);
    		super.setVisible(true);
    	}
    }
    
    public class MyMouseEventDemo02
    { 
    	public static void main(String args[])
    	{ 
    		new MyMouseHandle1();
    	}
    }

运行结果：  
![使用适配器监听鼠标事件][70 13]  
以上程序中因为使用了适配器MouseAdpter类，所以在实现程序是指需要实现需要覆盖mouseClicked()方法，所以只能处理鼠标单击事件。

## 鼠标拖拽事件及监听处理 ##

在一般的图形界面中经常可以看到鼠标拖拽操作的情况，在`Swing`的事件处理中可以使用`MouseMotionListener`接口完成鼠标的拖拽操作，`MouseMotionListener`接口中定义了下表的方法。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th></th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>void mouseDragged(MouseEvent e)</code></td> 
   <td>鼠标按键在<strong>组件上按下并拖动时调用</strong>。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><code>void mouseMoved(MouseEvent e)</code></td> 
   <td>鼠标<strong>光标移动到组件上但无按键按下时调用</strong>。</td> 
  </tr> 
 </tbody> 
</table>

实例：鼠标拖拽事件

import java.awt.event.WindowAdapter;
    import java.awt.event.MouseMotionListener;
    import java.awt.event.WindowEvent;
    import java.awt.event.MouseEvent;
    import javax.swing.JFrame;
    
    class MyMouseMotionHandle extends JFrame
    { 
    	public MyMouseMotionHandle()
    	{ 
    		super.setTitle("鼠标拖拽事件");
    		//窗体监听鼠标监听事件
    		super.addMouseMotionListener(new MouseMotionListener()
    		{ 
    			public void mouseDragged(MouseEvent e)
    			{ 
    				System.out
    						.println("鼠标拖拽到：X = " + e.getX() + "，Y = " + e.getY());
    			}
    			public void mouseMoved(MouseEvent e)
    			{ 
    				System.out.println("鼠标在窗体中移动");
    			}
    		});
    		super.addWindowListener(new WindowAdapter()
    		{ 
    			public void windowClosing(WindowEvent e)
    			{ 
    				System.exit(1);
    			}
    		});
    		super.setSize(310, 210);
    		super.setVisible(true);
    	}
    };
    
    public class MyMouseMotionEventDemo01
    { 
    	public static void main(String args[])
    	{ 
    		new MyMouseMotionHandle();
    	}
    };

运行结果：  
![运行结果][70 14]  
控制台打印：

鼠标在窗体中移动
    鼠标在窗体中移动
    鼠标在窗体中移动
    ......
    鼠标拖拽到：X = 290，Y = 173
    鼠标拖拽到：X = 289，Y = 173
    鼠标拖拽到：X = 288，Y = 172
    鼠标拖拽到：X = 287，Y = 171
    鼠标拖拽到：X = 286，Y = 170
    ......
    鼠标在窗体中移动
    鼠标在窗体中移动

可以看到程序运行以后，只要鼠标在窗体中移动就会触发鼠标移动事件`mouseMoved()`;只要是在窗体中拖拽，就会触发拖拽事件`mouseDragged()`。在鼠标拖拽事件操作中同样也存在`MouseMotinAdapter`类，如果使用`MouseMotinAdapter`类则可以只监听自己需要的事件。不在列举。

事件处理就介绍到这里啦。

[70]: /images/20220522/178fc73bd40f4451a5a34dfe620a0c53.png
[70 1]: /images/20220522/6fbeaa0ff64f4fdca1000b5ac4d0481e.png
[70 2]: /images/20220522/6694479866994beea487318929b00dc1.png
[70 3]: /images/20220522/9630045245324464bf016faa3294a8bb.png
[1]: /images/20220522/64c9752e63684bdd9e199449723d1519.png
[70 4]: /images/20220522/1cee3db6bcbe4df886308d0fe03b6415.png
[70 5]: /images/20220522/b778fa82822d426fa6b71e06edd8f7ee.png
[70 6]: /images/20220522/4111bc03f6c040e6b1f0f76f587b53c7.png
[70 7]: /images/20220522/ad63633eb4214c7ea55009bffc5c0765.png
[70 8]: /images/20220522/6a9f3307e7a64260995f440a301d2f0f.png
[70 9]: /images/20220522/469ab55b0ced41ab876591afefc3b362.png
[70 10]: /images/20220522/bc4d76ea62064862a6080eb953e20020.png
[70 11]: /images/20220522/ebe117f75fa94a9ba532a48de0c4e112.png
[70 12]: /images/20220522/195abe6c793d4263b740fddd52fd4956.png
[70 13]: /images/20220522/b0826124883844cb99eb47f45979dbe3.png
[70 14]: /images/20220522/1afc0ceea60240f1938e41b06042f7cc.png