java事件监听器

最新推荐文章于 2024-02-13 00:15:00 发布

程程呀

最新推荐文章于 2024-02-13 00:15:00 发布

阅读量1w

点赞数 22

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_31755183/article/details/103631352

版权

java 专栏收录该内容

30 篇文章 1 订阅

订阅专栏

1.动作事件监听器

动作事件（ActionEvent）监听器是Swing中比较常用的事件监听器，很组件的动作都会使用它监听，如按钮单击，下表描述了动作事件监听器的接口与事件源。

事件名称	事件源	监听接口	添加或删除相应类型监听器的方法
ActionEvent	JButton、JList、JTextField等	ActionListener	addActionListener()、removeActionListener()

动作事件监听器可以为按钮、列表、列表框、文本等组件进行监听，下面以按钮为例将讲解动作监听器的用法，代码如下：


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

import javax.swing.*;

public class Dpc extends JFrame{

	private JButton jb=new JButton("我是按钮，单击我");
	public Dpc(){
		setLayout(null);
		setSize(200,100);
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
		Container cp=getContentPane();
		cp.add(jb);
		jb.setBounds(10, 10,100,30);
		//对按钮添加监听器
		jb.addActionListener(new jbAction());
		setVisible(true);
	}
	//创建监听器接口
	class jbAction implements ActionListener{
		public void actionPerformed(ActionEvent arg0) {
			jb.setText("我被单击了");
		}
	}
	public static void main(String[] args) {
		new Dpc();
	}
}

返回结果：

在上述实例中，为按钮设置了动作事件监听器，由于获取事件监听时需要获取实现ActionListener接口的对象，所以定义了一个内部类JbAction，来实现ActionListener接口，同时在该内部类中实现了actionPerformed方法，也就是在actionPerformed()方法中定义当用户单击该按钮后的实现效果。

上述代码中也可以这么写，把内部类写在jb.addActionListener(）中，代码如下：

jb.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent arg0) {
		jb.setText("我被单击了");
	}
});

2.键盘事件

当向文本框中输入文本内容时，将触发键盘事件，keyEvent类负责捕获键盘事件，可以通过为组件添加实现了KeyListener接口的监听器类，来处理该组件触发的键盘事件。KeyListener接口共有三个抽象方法，分别发生在击键事件（按下并释放键）、按键被按下（手指按下键但不松开）和按键被释放（手指从按下的键上松开）时被触发。KeyListener接口的具体定义如下：

public interface KeyEvent extends EventListener{
	//发生击键事件时被触发
	public void keyTyped(keyEvent e);
	//按键被按下时被触发
	public void keyPressed(keyEvent e);
	//按键被释放时被触发
	public void keyReleased(keyEvent e);
}

在每个抽象方法中均传入了KeyEvent类对象，KeyEvent类中比较常用的方法如下表：

方法	功能简介
getSource()	用来获取触发此事件的组件对象，返回值Object对象
getKeyChar()	用来获得与此事件中的键相关联字符
getKeyCode()	用来获得与此事件中的键相关联的整数keyCode
getrKeyText(int keyCode)	用来获得描述keyCode的标签，如A、F1和HOME等
isActionKey()	用来查看此事件中的键是否为"动作"键
isControlDown()	用来查看Ctrl键在此事件中是否被按下，当返回true时表示被按下
isAltDown()	用来查看Alt键在此事件中是否被按下，当返回true时表示被按下
isShiftDown()	用来查看Shift键在此事件中是否被按下，当返回true时表示被按下

下面通过一个例子在演示键盘事件的用法，代码如下：

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Demo extends JFrame{
	public Demo() {
		Container ct = getContentPane();
		ct.setLayout(new GridLayout(2,1,10,10));
		setBounds(100, 100, 200, 100);
		
		//设置面板
		JPanel jp1 = new JPanel(new FlowLayout());
		JPanel jp2 = new JPanel(new FlowLayout());
		
		//设置文本框
		JTextField jt = new JTextField();
		jt.setColumns(10);
		jp1.add(jt);

		//设置标签
		JLabel jl = new JLabel();
		jp2.add(jl);
		//设置键盘事件
		jt.addKeyListener(new KeyListener() {
			//按键被按下时被触发
			public void keyReleased(KeyEvent e) {
				//清空文本框内容
				jt.setText("");				
			}
			//按键被按下时被触发
			public void keyPressed(KeyEvent e) {
				jl.setText("你输入的字符为：" + e.getKeyChar());			
			}
			public void keyTyped(KeyEvent e) {
	
			}
		});
		//将面板添加到容器
		ct.add(jp1);
		ct.add(jp2);
		
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		
	}
	public static void main(String[] args) {
		new Demo();
	}
}

返回结果：

以下是模拟键盘的代码：


import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Color;
import java.awt.Component;

import javax.swing.JButton;
import java.awt.Font;
import javax.swing.SwingConstants;
import javax.swing.border.TitledBorder;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;

import javax.swing.JTextField;

/**
 * 虚拟键盘(键盘的按下与释放)
 */
public class Dpc extends JFrame { //创建“键盘”类继承JFrame
	//声明窗体中的成员组件
	private JPanel contentPane;
	private JTextField textField;
	private JButton btnQ;
	private JButton btnW;
	private JButton btnE;
	private JButton btnR;
	private JButton btnT;
	private JButton btnY;
	private JButton btnU;
	private JButton btnI;
	private JButton btnO;
	private JButton btnP;
	private JButton btnA;
	private JButton btnS;
	private JButton btnD;
	private JButton btnF;
	private JButton btnG;
	private JButton btnH;
	private JButton btnJ;
	private JButton btnK;
	private JButton btnL;
	private JButton btnZ;
	private JButton btnX;
	private JButton btnC;
	private JButton btnV;
	private JButton btnB;
	private JButton btnN;
	private JButton btnM;
	Color green=Color.GREEN;//定义Color对象，用来表示按下键的颜色
	Color white=Color.WHITE;//定义Color对象，用来表示释放键的颜色
	
	ArrayList<JButton> btns=new ArrayList<JButton>();//定义一个集合，用来存储所有的按键ID
	//自定义一个方法，用来将容器中的所有JButton组件添加到集合中
	private void addButtons(){
		for(Component cmp :contentPane.getComponents()){//遍历面板中的所有组件
			if(cmp instanceof JButton){//判断组件的类型是否为JButton类型
				btns.add((JButton)cmp);//将JButton组件添加到集合中
			}
		}
	}

	/**
	 * 主方法
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() { //使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
			public void run() {
				try {
					Dpc frame = new Dpc(); //创建KeyBoard对象
					frame.setVisible(true); //使frame可视
					frame.addButtons();//初始化存储所有按键的集合
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * 创建JFrame窗体
	 */
	public Dpc() { //KeyBoard的构造方法
		setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09"); //设置窗体题目
		setResizable(false); //不可改变窗体宽高
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置窗体关闭的方式
		setBounds(100, 100, 548, 280); //设置窗体的位置和宽高
		/**
		 * 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
		 */
		contentPane = new JPanel();
		contentPane.setBackground(Color.WHITE);
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(contentPane);
		contentPane.setLayout(null);
		/**
		 * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnQ = new JButton("Q");
		btnQ.setBackground(white);
		btnQ.setVerticalAlignment(SwingConstants.TOP);
		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnQ.setBounds(0, 60, 47, 45);
		contentPane.add(btnQ);
		/**
		 * 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnW = new JButton("W");
		btnW.setBackground(white);
		btnW.setVerticalAlignment(SwingConstants.TOP);
		btnW.setHorizontalAlignment(SwingConstants.LEADING);
		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnW.setBounds(55, 60, 49, 45);
		contentPane.add(btnW);
		/**
		 * 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnE = new JButton("E");
		btnE.setBackground(white);
		btnE.setVerticalAlignment(SwingConstants.TOP);
		btnE.setHorizontalAlignment(SwingConstants.LEADING);
		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnE.setBounds(110, 60, 45, 45);
		contentPane.add(btnE);
		/**
		 * 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnR = new JButton("R");
		btnR.setBackground(white);
		btnR.setVerticalAlignment(SwingConstants.TOP);
		btnR.setHorizontalAlignment(SwingConstants.LEADING);
		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnR.setBounds(165, 60, 45, 45);
		contentPane.add(btnR);
		/**
		 * 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnF = new JButton("F");
		btnF.setBackground(white);
		btnF.setVerticalAlignment(SwingConstants.TOP);
		btnF.setHorizontalAlignment(SwingConstants.LEADING);
		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnF.setBounds(195, 125, 45, 45);
		contentPane.add(btnF);
		/**
		 * 创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnD = new JButton("D");
		btnD.setBackground(white);
		btnD.setVerticalAlignment(SwingConstants.TOP);
		btnD.setHorizontalAlignment(SwingConstants.LEADING);
		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnD.setBounds(137, 125, 45, 45);
		contentPane.add(btnD);
		
		btnT = new JButton("T");
		btnT.setVerticalAlignment(SwingConstants.TOP);
		btnT.setHorizontalAlignment(SwingConstants.LEADING);
		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnT.setBackground(white);
		btnT.setBounds(220, 60, 45, 45);
		contentPane.add(btnT);
		
		btnY = new JButton("Y");
		btnY.setVerticalAlignment(SwingConstants.TOP);
		btnY.setHorizontalAlignment(SwingConstants.LEADING);
		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnY.setBackground(white);
		btnY.setBounds(275, 60, 45, 45);
		contentPane.add(btnY);
		
		btnU = new JButton("U");
		btnU.setVerticalAlignment(SwingConstants.TOP);
		btnU.setHorizontalAlignment(SwingConstants.LEADING);
		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnU.setBackground(white);
		btnU.setBounds(330, 60, 45, 45);
		contentPane.add(btnU);
		
		btnI = new JButton("I");
		btnI.setVerticalAlignment(SwingConstants.TOP);
		btnI.setHorizontalAlignment(SwingConstants.LEADING);
		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnI.setBackground(white);
		btnI.setBounds(385, 60, 45, 45);
		contentPane.add(btnI);
		
		btnO = new JButton("O");
		btnO.setVerticalAlignment(SwingConstants.TOP);
		btnO.setHorizontalAlignment(SwingConstants.LEADING);
		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnO.setBackground(white);
		btnO.setBounds(440, 60, 46, 45);
		contentPane.add(btnO);
		
		btnP = new JButton("P");
		btnP.setVerticalAlignment(SwingConstants.TOP);
		btnP.setHorizontalAlignment(SwingConstants.LEADING);
		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnP.setBackground(white);
		btnP.setBounds(495, 60, 45, 45);
		contentPane.add(btnP);
		
		btnA = new JButton("A");
		btnA.setVerticalAlignment(SwingConstants.TOP);
		btnA.setHorizontalAlignment(SwingConstants.LEADING);
		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnA.setBackground(white);
		btnA.setBounds(23, 125, 45, 45);
		contentPane.add(btnA);
		
		btnS = new JButton("S");
		btnS.setVerticalAlignment(SwingConstants.TOP);
		btnS.setHorizontalAlignment(SwingConstants.LEADING);
		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnS.setBackground(white);
		btnS.setBounds(82, 125, 45, 45);
		contentPane.add(btnS);
		
		btnG = new JButton("G");
		btnG.setVerticalAlignment(SwingConstants.TOP);
		btnG.setHorizontalAlignment(SwingConstants.LEADING);
		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnG.setBackground(white);
		btnG.setBounds(251, 125, 45, 45);
		contentPane.add(btnG);
		
		btnH = new JButton("H");
		btnH.setVerticalAlignment(SwingConstants.TOP);
		btnH.setHorizontalAlignment(SwingConstants.LEADING);
		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnH.setBackground(white);
		btnH.setBounds(306, 125, 45, 45);
		contentPane.add(btnH);
		
		btnJ = new JButton("J");
		btnJ.setVerticalAlignment(SwingConstants.TOP);
		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnJ.setBackground(white);
		btnJ.setBounds(361, 125, 45, 45);
		contentPane.add(btnJ);
		
		btnK = new JButton("K");
		btnK.setVerticalAlignment(SwingConstants.TOP);
		btnK.setHorizontalAlignment(SwingConstants.LEADING);
		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnK.setBackground(white);
		btnK.setBounds(416, 125, 47, 45);
		contentPane.add(btnK);
		
		btnL = new JButton("L");
		btnL.setVerticalAlignment(SwingConstants.TOP);
		btnL.setHorizontalAlignment(SwingConstants.LEADING);
		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnL.setBackground(white);
		btnL.setBounds(471, 125, 45, 45);
		contentPane.add(btnL);
		
		btnZ = new JButton("Z");
		btnZ.setVerticalAlignment(SwingConstants.TOP);
		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnZ.setBackground(white);
		btnZ.setBounds(39, 190, 45, 45);
		contentPane.add(btnZ);
		
		btnX = new JButton("X");
		btnX.setVerticalAlignment(SwingConstants.TOP);
		btnX.setHorizontalAlignment(SwingConstants.LEADING);
		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnX.setBackground(white);
		btnX.setBounds(107, 190, 45, 45);
		contentPane.add(btnX);
		
		btnC = new JButton("C");
		btnC.setVerticalAlignment(SwingConstants.TOP);
		btnC.setHorizontalAlignment(SwingConstants.LEADING);
		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnC.setBackground(white);
		btnC.setBounds(178, 190, 45, 45);
		contentPane.add(btnC);
		
		btnV = new JButton("V");
		btnV.setVerticalAlignment(SwingConstants.TOP);
		btnV.setHorizontalAlignment(SwingConstants.LEADING);
		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnV.setBackground(white);
		btnV.setBounds(250, 190, 45, 45);
		contentPane.add(btnV);
		
		btnB = new JButton("B");
		btnB.setVerticalAlignment(SwingConstants.TOP);
		btnB.setHorizontalAlignment(SwingConstants.LEADING);
		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnB.setBackground(white);
		btnB.setBounds(315, 190, 45, 45);
		contentPane.add(btnB);
		
		btnN = new JButton("N");
		btnN.setVerticalAlignment(SwingConstants.TOP);
		btnN.setHorizontalAlignment(SwingConstants.LEADING);
		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnN.setBackground(white);
		btnN.setBounds(382, 190, 47, 45);
		contentPane.add(btnN);
		
		btnM = new JButton("M");
		btnM.setVerticalAlignment(SwingConstants.TOP);
		btnM.setHorizontalAlignment(SwingConstants.LEADING);
		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnM.setBackground(white);
		btnM.setBounds(449, 190, 48, 45);
		contentPane.add(btnM);
		/**
		 * 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
		 */
		JPanel panel = new JPanel();
		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
		panel.setBackground(Color.WHITE);
		panel.setBounds(0, 0, 540, 45);
		contentPane.add(panel);
		panel.setLayout(new BorderLayout(0, 0));
		
		
		/**
		 * 创建文本框textField置于面板panel的中间
		 */
		textField = new JTextField();
		textField.addKeyListener(new KeyAdapter() { //文本框添加键盘事件的监听
			char word;
			@Override
			public void keyPressed(KeyEvent e) { //按键被按下时被触发
				word=e.getKeyChar();//获取按下键表示的字符
				for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
					//判断按键是否与遍历到的按键的文本相同
					if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
						btns.get(i).setBackground(green);//将指定按键颜色设置为绿色
					}
				}
			}
			@Override
			public void keyReleased(KeyEvent e) { //按键被释放时被触发
				word=e.getKeyChar();//获取释放键表示的字符
				for(int i=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
					//判断按键是否与遍历到的按键的文本相同
					if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
						btns.get(i).setBackground(white);//将指定按键颜色设置为白色
					}
				}
			}
		});
		panel.add(textField, BorderLayout.CENTER);
		textField.setColumns(10);
	}
}

返回结果：

3.鼠标事件

所有组件都能应用鼠标事件，MouseEvent类负责捕获鼠标事件，可以通过为组件添加实现了MouseListener接口的监听器类来处理该组件触发的鼠标事件，

MouseListener接口共有5个抽象方法，分别在光标移入或移出组件、鼠标按键被按下或释放和发生单击事件时被触发，所谓单击事件，就是鼠标按键被按下并释放，需要注意的是，如果鼠标按键是在移出组件之后被释放，则不会触发单击事件，接口中各个方法的代码如下：

public void mouseReleased(MouseEvent e) {
    //鼠标按键被释放时被触发
}

public void mousePressed(MouseEvent e) {
	//鼠标按键被按下时被触发
}

public void mouseExited(MouseEvent e) {
	//光标移出组件时被触发	
}

public void mouseEntered(MouseEvent e) {
    //光标移入组件时被触发
}

public void mouseClicked(MouseEvent e) {
	//发生单击事件时被触发
}

在每个抽象方法中均转入了MouseEvent类的对象，MouseEvent类中比较常用的方法如下表：

方法	功能简介
getSource()	用来获得触发此事件的组件对象，返回值为Object类型
getButton()	用来获得代表此次被按下、被释放或被单击的按键的int值
getClickCount()	用来获得按键被单击的次数

当需要判断触发此次事件的鼠标按键时，可以通过比较由getButton()方法返回的int值和下表中的静态常量的方式获得：

静态常量	常量值	代表的键
BUTTON1	1	代表鼠标左键
BUTTON2	2	代表鼠标滚轮
BUTTON3	3	代表鼠标右键

下面实例讲解鼠标事件，代码如下：

import java.awt.Color;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;


import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.LineBorder;

public class Demo extends JFrame{
	public Demo() {
		Container ct = getContentPane();
		setBounds(200, 200, 500, 300);
		ct.setLayout(null);
		//创建滚动面板
		JScrollPane jsc = new JScrollPane();
		jsc.setBounds(32, 27, 183, 216);
		ct.add(jsc);
		//创建文本域
		JTextArea jt = new JTextArea();
		jsc.setViewportView(jt);
		//创建标签
		JLabel jl = new JLabel();
		jl.setBounds(244, 57, 160, 141);
		jl.setBorder(new LineBorder(Color.red));
		ct.add(jl);
		//创建鼠标区域标签
		JLabel jl1 = new JLabel("鼠标点击区域");
		jl1.setBounds(281, 32, 84, 15);
		ct.add(jl1);
		//给鼠标区域标签创建鼠标事件
		jl.addMouseListener(new MouseListener() {
			//鼠标按键被释放时被触发
			public void mouseReleased(MouseEvent e) {
				jt.append("鼠标释放\n");
				
			}
			//鼠标按键被按下时被触发
			public void mousePressed(MouseEvent e) {
				jt.append("鼠标按下\n");
				
			}
			//光标移出组件时被触发
			public void mouseExited(MouseEvent e) {
				jt.append("光标移出\n");
				
			}
			//光标移入组件时被触发
			public void mouseEntered(MouseEvent e) {
				jt.append("光标移入\n");
			}
			//发生单击事件时被触发
			public void mouseClicked(MouseEvent e) {
				int sum = e.getClickCount();
				int i = e.getButton(); // 通过该值可以判断按下的是哪个键
				if (i == MouseEvent.BUTTON1)
					jt.append("按下的是鼠标左键\n");
				else if (i == MouseEvent.BUTTON2)
					jt.append("按下的是鼠标滚轮\n");
				else if (i == MouseEvent.BUTTON3)
					jt.append("按下的是鼠标右键\n");
				
				jt.append("鼠标单击" + sum + "次\n");
				
			}
		});
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		new Demo();
	}
}

返回结果：

4.窗体事件

需要捕获与窗体有关的事件时（如捕获窗体被打开、将要被关闭、已经被关闭事件），可以通过实现了WindowListener接口的事件监听器完成，WindowListener接口中各个方法的代码如下：

	
		public void windowActivated(WindowEvent e) {
	        // 窗体被激活时触发
		}

		public void windowOpened(WindowEvent e) {
            // 窗体被打开时触发
		}

		public void windowIconified(WindowEvent e) {
	        // 窗体被最小化时触发
		}

		public void windowDeiconified(WindowEvent e) {
	        // 窗体被非最小化时触发
		}

		public void windowClosing(WindowEvent e) {
            // 窗体将要被关闭时触发
		}

		public void windowDeactivated(WindowEvent e) {
            // 窗体不再处于激活状态时触发
		}

		public void windowClosed(WindowEvent e) {
	        // 窗体已经被关闭时触发
		}

窗体激活事件和窗体获得焦点事件的区别如下：

窗体激活事件时WindowListener接口中提供的事件，而窗体获得焦点事件是WindowFocusListener接口中提供的；
执行顺序不同：窗体激活→获得焦点→失去焦点→窗体不处于被激活状态；

通过捕获窗体将要被关闭事件，可以执行一些相关的操作，例如，窗体将要被关闭时，询问是否保存未保存的设置或者弹出确认关闭对话框等，下面是一个用来演示捕获窗体事件的典型实例：


import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import java.awt.event.WindowListener;

import javax.swing.JFrame;

public class Dpc extends JFrame {

	public static void main(String args[]) {
		Dpc frame = new Dpc();
		frame.setVisible(true);
	}

	public Dpc() {
		super();
		addWindowListener(new MyWindowListener());// 为窗体添加其他事件监听器
		setTitle("捕获其他窗体事件");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
	}

	private class MyWindowListener implements WindowListener {
		public void windowActivated(WindowEvent e) {// 窗体被激活时触发
			System.out.println("窗口被激活！");
		}

		public void windowOpened(WindowEvent e) {// 窗体被打开时触发
			System.out.println("窗口被打开！");
		}

		public void windowIconified(WindowEvent e) {// 窗体被最小化时触发
			System.out.println("窗口被最小化！");
		}

		public void windowDeiconified(WindowEvent e) {// 窗体被非最小化时触发
			System.out.println("窗口被非最小化！");
		}

		public void windowClosing(WindowEvent e) {// 窗体将要被关闭时触发
			System.out.println("窗口将要被关闭！");
		}

		// 窗体不再处于激活状态时触发
		public void windowDeactivated(WindowEvent e) {
			System.out.println("窗口不再处于激活状态！");
		}

		public void windowClosed(WindowEvent e) {// 窗体已经被关闭时触发
			System.out.println("窗口已经被关闭！");
		}
	}
}

返回结果：

程程呀

关注

22
点赞
踩
169

收藏

觉得还不错? 一键收藏
0
评论
java事件监听器

1.动作事件监听器动作事件（ActionEvent）监听器是Swing中比较常用的事件监听器，很组件的动作都会使用它监听，如按钮单击，下表描述了动作事件监听器的接口与事件源。事件名称事件源监听接口添加或删除相应类型监听器的方法 ActionEvent JButton、JList、JTextField等 ActionListener addAct...
复制链接

扫一扫