【java】第十三章、高级事件处理

最新推荐文章于 2022-10-20 18:46:06 发布

我真的太下饭唠

最新推荐文章于 2022-10-20 18:46:06 发布

阅读量1.2k

点赞数 1

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

本文链接：https://blog.csdn.net/jgtzfcfzyc/article/details/117706555

版权

java学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的各种事件处理，包括键盘事件、鼠标事件、窗体焦点事件、窗体状态事件、窗体事件和选项事件。键盘事件通过KeyListener接口处理，鼠标事件使用MouseListener接口，窗体焦点和状态事件分别由WindowFocusListener和WindowStateListener接口处理，窗体事件则通过WindowListener接口实现。此外，还讲解了如何监听和响应下拉列表框、复选框和单选框的选项事件。

摘要由CSDN通过智能技术生成

键盘事件

java中处理键盘事件的方法：KeyListener键盘监听（它是一个接口，一共有3种抽象方法）
在这里插入图片描述
KeyEvent提供了很多静态常量，而这些静态常量就分别代表了键盘上不同的按键

在文本框中添加键盘监听（参数是创建KeyListener的匿名内部类），会跳出来重写三个方法，我们只要重写俩个就行（按键被按下、按键释放）
用switch来判断案件代码代表的是哪个按键（使用KeyEvent提供的静态常量）。另外要注意，当释放这个键时，颜色再变回去
但是，键盘上一共有26个字母，可以不用写26个case，去运用简单的方法：既然我们已经有了按钮对象，把所有这些按钮对象放在一个集合中

package keyboard_event;

import java.awt.*;
import java.util.List;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;

public class KeyBoard 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;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() { // 使得Runnable中的run()方法在the system EventQueue
			public void run() { // 的指派线程中被调用
				try {
					KeyBoard frame = new KeyBoard(); // 创建KeyBoard对象
					frame.setVisible(true); // 使窗体frame可视
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public KeyBoard() { // KeyBoard的构造方法

		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));
//		contentPane.setLayout(new BorderLayout(0, 0));
		setContentPane(contentPane);
		contentPane.setLayout(null);

		/**
		 * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnQ = new JButton("Q");
		btnQ.setBackground(Color.WHITE);
		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
		btnQ.setVerticalAlignment(SwingConstants.TOP);
		btnQ.setBounds(0, 60, 47, 45);
		contentPane.add(btnQ);

		/**
		 * 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
		 */
		btnW = new JButton("W");
		btnW.setBackground(Color.WHITE);
		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnW.setHorizontalAlignment(SwingConstants.LEADING);
		btnW.setVerticalAlignment(SwingConstants.TOP);
		btnW.setBounds(55, 60, 49, 45);
		contentPane.add(btnW);

		btnE = new JButton("E");
		btnE.setBackground(Color.WHITE);
		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnE.setHorizontalAlignment(SwingConstants.LEADING);
		btnE.setVerticalAlignment(SwingConstants.TOP);
		btnE.setBounds(110, 60, 45, 45);
		contentPane.add(btnE);

		btnR = new JButton("R");
		btnR.setBackground(Color.WHITE);
		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnR.setHorizontalAlignment(SwingConstants.LEADING);
		btnR.setVerticalAlignment(SwingConstants.TOP);
		btnR.setBounds(165, 60, 45, 45);
		contentPane.add(btnR);

		btnF = new JButton("F");
		btnF.setBackground(Color.WHITE);
		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnF.setHorizontalAlignment(SwingConstants.LEADING);
		btnF.setVerticalAlignment(SwingConstants.TOP);
		btnF.setBounds(195, 125, 45, 45);
		contentPane.add(btnF);

		btnD = new JButton("D");
		btnD.setBackground(Color.WHITE);
		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnD.setHorizontalAlignment(SwingConstants.LEADING);
		btnD.setVerticalAlignment(SwingConstants.TOP);
		btnD.setBounds(137, 125, 45, 45);
		contentPane.add(btnD);

		btnT = new JButton("T");
		btnT.setBackground(Color.WHITE);
		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnT.setHorizontalAlignment(SwingConstants.LEADING);
		btnT.setVerticalAlignment(SwingConstants.TOP);
		btnT.setBounds(220, 60, 45, 45);
		contentPane.add(btnT);

		btnY = new JButton("Y");
		btnY.setBackground(Color.WHITE);
		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnY.setHorizontalAlignment(SwingConstants.LEADING);
		btnY.setVerticalAlignment(SwingConstants.TOP);
		btnY.setBounds(275, 60, 45, 45);
		contentPane.add(btnY);

		btnU = new JButton("U");
		btnU.setBackground(Color.WHITE);
		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnU.setHorizontalAlignment(SwingConstants.LEADING);
		btnU.setVerticalAlignment(SwingConstants.TOP);
		btnU.setBounds(330, 60, 45, 45);
		contentPane.add(btnU);

		btnI = new JButton("I");
		btnI.setBackground(Color.WHITE);
		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnI.setHorizontalAlignment(SwingConstants.LEADING);
		btnI.setVerticalAlignment(SwingConstants.TOP);
		btnI.setBounds(385, 60, 45, 45);
		contentPane.add(btnI);

		btnO = new JButton("O");
		btnO.setBackground(Color.WHITE);
		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnO.setHorizontalAlignment(SwingConstants.LEADING);
		btnO.setVerticalAlignment(SwingConstants.TOP);
		btnO.setBounds(440, 60, 46, 45);
		contentPane.add(btnO);

		btnP = new JButton("P");
		btnP.setBackground(Color.WHITE);
		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnP.setHorizontalAlignment(SwingConstants.LEADING);
		btnP.setVerticalAlignment(SwingConstants.TOP);
		btnP.setBounds(495, 60, 45, 45);
		contentPane.add(btnP);

		btnA = new JButton("A");
		btnA.setBackground(Color.WHITE);
		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnA.setHorizontalAlignment(SwingConstants.LEADING);
		btnA.setVerticalAlignment(SwingConstants.TOP);
		btnA.setBounds(23, 125, 45, 45);
		contentPane.add(btnA);

		btnS = new JButton("S");
		btnS.setBackground(Color.WHITE);
		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnS.setHorizontalAlignment(SwingConstants.LEADING);
		btnS.setVerticalAlignment(SwingConstants.TOP);
		btnS.setBounds(82, 125, 45, 45);
		contentPane.add(btnS);

		btnG = new JButton("G");
		btnG.setBackground(Color.WHITE);
		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnG.setHorizontalAlignment(SwingConstants.LEADING);
		btnG.setVerticalAlignment(SwingConstants.TOP);
		btnG.setBounds(251, 125, 45, 45);
		contentPane.add(btnG);

		btnH = new JButton("H");
		btnH.setBackground(Color.WHITE);
		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnH.setHorizontalAlignment(SwingConstants.LEADING);
		btnH.setVerticalAlignment(SwingConstants.TOP);
		btnH.setBounds(306, 125, 45, 45);
		contentPane.add(btnH);

		btnJ = new JButton("J");
		btnJ.setBackground(Color.WHITE);
		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
		btnJ.setVerticalAlignment(SwingConstants.TOP);
		btnJ.setBounds(361, 125, 45, 45);
		contentPane.add(btnJ);

		btnK = new JButton("K");
		btnK.setBackground(Color.WHITE);
		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnK.setHorizontalAlignment(SwingConstants.LEADING);
		btnK.setVerticalAlignment(SwingConstants.TOP);
		btnK.setBounds(416, 125, 47, 45);
		contentPane.add(btnK);

		btnL = new JButton("L");
		btnL.setBackground(Color.WHITE);
		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnL.setHorizontalAlignment(SwingConstants.LEADING);
		btnL.setVerticalAlignment(SwingConstants.TOP);
		btnL.setBounds(471, 125, 45, 45);
		contentPane.add(btnL);

		btnZ = new JButton("Z");
		btnZ.setBackground(Color.WHITE);
		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
		btnZ.setVerticalAlignment(SwingConstants.TOP);
		btnZ.setBounds(39, 190, 45, 45);
		contentPane.add(btnZ);

		btnX = new JButton("X");
		btnX.setBackground(Color.WHITE);
		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnX.setHorizontalAlignment(SwingConstants.LEADING);
		btnX.setVerticalAlignment(SwingConstants.TOP);
		btnX.setBounds(107, 190, 45, 45);
		contentPane.add(btnX);

		btnC = new JButton("C");
		btnC.setBackground(Color.WHITE);
		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnC.setHorizontalAlignment(SwingConstants.LEADING);
		btnC.setVerticalAlignment(SwingConstants.TOP);
		btnC.setBounds(178, 190, 45, 45);
		contentPane.add(btnC);

		btnV = new JButton("V");
		btnV.setBackground(Color.WHITE);
		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnV.setHorizontalAlignment(SwingConstants.LEADING);
		btnV.setVerticalAlignment(SwingConstants.TOP);
		btnV.setBounds(256, 190, 45, 45);
		contentPane.add(btnV);

		btnB = new JButton("B");
		btnB.setBackground(Color.WHITE);
		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnB.setHorizontalAlignment(SwingConstants.LEADING);
		btnB.setVerticalAlignment(SwingConstants.TOP);
		btnB.setBounds(315, 190, 45, 45);
		contentPane.add(btnB);

		btnN = new JButton("N");
		btnN.setBackground(Color.WHITE);
		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnN.setHorizontalAlignment(SwingConstants.LEADING);
		btnN.setVerticalAlignment(SwingConstants.TOP);
		btnN.setBounds(382, 190, 47, 45);
		contentPane.add(btnN);

		btnM = new JButton("M");
		btnM.setBackground(Color.WHITE);
		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 16));
		btnM.setHorizontalAlignment(SwingConstants.LEADING);
		btnM.setVerticalAlignment(SwingConstants.TOP);
		btnM.setBounds(449, 190, 48, 45);
		contentPane.add(btnM);

		/**
		 * 创建面板panel置于面板contentPane中，设置面板panel的位置和宽高，TitleBorder、背景色以及布局方式（边界布局）
		 */
		JPanel panel = new JPanel();
		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP));
		panel.setBackground(Color.WHITE);
		panel.setBounds(0, 0, 540, 45);
		contentPane.add(panel);
		panel.setLayout(new BorderLayout(0, 0));

		/**
		 * 创建文本框textField置于面板panel的中间
		 */
		textField = new JTextField();
		panel.add(textField, BorderLayout.CENTER);
		textField.setColumns(10);
		
		List<JButton> list = new ArrayList<>();
		Component items[] = contentPane.getComponents();    //返回容器中所有的组件
		for(Component c: items) {
			if(c instanceof JButton) {                      //如果这个组件是按钮
				list.add((JButton)c);
			}
		}
		
		textField.addKeyListener(new KeyListener() {
			@Override
			public void keyPressed(KeyEvent e) {           //按键被按下
				char ch = e.getKeyChar();                  //获取按键字符
				for(JButton btn: list) {
					String btnText = btn.getText();
					if(btnText.equalsIgnoreCase(String.valueOf(ch))) {
						btn.setBackground(Color.green);
					}
				}
			}

			@Override
			public void keyReleased(KeyEvent e) {          //按键释放
				char ch = e.getKeyChar();                  //获取按键字符
				for(JButton btn: list) {
					String btnText = btn.getText();
					if(btnText.equalsIgnoreCase(String.valueOf(ch))) {
						btn.setBackground(Color.white);
					}
				}
			}

			@Override
			public void keyTyped(KeyEvent e) {
				
			}
			
		});
		
	}
}

键盘事件监听：在给组件添加键盘事件监听时，java虚拟机会自动捕获用户输入的指令（通过具体方法来看用户输入的到底是哪个指令），再根据用户输入的指令让程序做出相应操作

鼠标事件

在这里插入图片描述
鼠标按下+释放，做完这一套动作之后，不同的程序会对我们的动作做出不同的反应。而这个动作触发的事件就叫做鼠标事件。

在java中，我们使用MouseListener来监听鼠标事件（它也是一个接口，有5个方法）
在这里插入图片描述

鼠标事件监听可以知道用户点击了几次，以及按下的是哪个按键
鼠标事件e的一个方法getButton返回的是一个int值，获取用户点击了哪个按键（按钮的一个代码）；getClickCount可以获取用户点击的次数

package mouse_event;

import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.*;
import javax.swing.border.*;

public class Mouse extends JFrame {              //继承窗体类JFrame

	private JPanel contentPane;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					Mouse frame = new Mouse();
					frame.setVisible(true);     //设置窗体可见
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public Mouse() {
		setTitle("鼠标事件示例");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 473, 321);
		getContentPane().setLayout(null);
		
		final JLabel label = new JLabel();
		label.setBounds(244, 57, 160, 141);
		label.setBorder(new LineBorder(Color.red, 2));
		getContentPane().add(label);
		
		JScrollPane scrollPane = new JScrollPane();
		scrollPane.setBounds(32, 27, 183, 216);
		getContentPane().add(scrollPane);
		
		JTextArea textArea = new JTextArea();
		scrollPane.setViewportView(textArea);
		
		JLabel label_1 = new JLabel("鼠标点击区域");
		label_1.setBounds(281, 32, 84, 15);
		getContentPane().add(label_1);
		
		label.addMouseListener(new MouseListener() {

			@Override
			public void mouseClicked(MouseEvent e) {      //鼠标点击
				textArea.append("点击了鼠标按键\n");
				
				int btn = e.getButton();
				switch(btn) {
				case MouseEvent.BUTTON1:
					textArea.append("按下的是鼠标左键\n");
					break;
				case MouseEvent.BUTTON2:
					textArea.append("按下的是鼠标滚轮键\n");
					break;	
				case MouseEvent.BUTTON3:
					textArea.append("按下的是鼠标右键\n");
					break;	
				}
				
				int count = e.getClickCount();           //鼠标点击次数
				textArea.append("鼠标点击了" + count + "次\n");
			}

			@Override
			public void mousePressed(MouseEvent e) {     //按键按下
				textArea.append("鼠标按键被按下\n");
			}

			@Override
			public void mouseReleased(MouseEvent e) {     //按键释放
				textArea.append("鼠标按键被释放\n");
			}

			@Override
			public void mouseEntered(MouseEvent e) {      //鼠标进入
				textArea.append("鼠标进入组件\n");
			}

			@Override
			public void mouseExited(MouseEvent e) {       //鼠标退出
				textArea.append("鼠标离开组件\n");
			}
			
		});
		
	}
}

窗体焦点事件

在这里插入图片描述
当窗体得到或失去焦点时，会触发一个事件，这个事件就是窗体焦点事件
在java中，用WindowFocusListener来对窗体焦点事件进行监听（WindowFocusListener是一个接口，它有两个方法）

这里有两个label，第一个label是一个标签（输出一行话），第二个标签放的是一个图片。我们只需要在切换窗体焦点时，对这两个标签进行操作就行了
给窗体添加焦点事件监听：

package forms_focus_event;

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

import javax.swing.*;
import javax.swing.border.*;

public class Forms_Focus extends JFrame {         //创建一个“焦点”类，并继承JFrame
/**
 * 焦点事件的监听，使用焦点事件的监听模拟点亮灯泡的过程
 */
	//声明窗体中的组件
	private JPanel contentPane;
	private JLabel lblTip;
	private JLabel lblLight;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					Forms_Focus frame = new Forms_Focus();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public Forms_Focus() {                //Focus的构造方法
		setResizable(false);              //不可改变窗体大小
		setTitle("焦点事件的监听");           //设置窗体题目
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 300, 300);
		
		/**
		 * 创建JPanel面板contentPane置于JFrame窗体中，并设置面板背景色、边距和布局）
		 */
		contentPane = new JPanel();
		contentPane.setBackground(Color.BLACK);
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		contentPane.setLayout(new BorderLayout(0, 0));
		setContentPane(contentPane);
		
		/**
		 * 创建标签lblTip置于JFrame窗体中的南侧，设置该标签中字体的颜色、样式以及水平居中
		 */
		lblTip = new JLabel("JFrame窗体获得焦点，灯亮了！");
		lblTip.setHorizontalAlignment(SwingConstants.CENTER);
		lblTip.setFont(new Font("微软雅黑", Font.PLAIN, 14));
		lblTip.setForeground(Color.CYAN);
		contentPane.add(lblTip, BorderLayout.SOUTH);
		
		/**
		 * 创建标签lblLight置于JFrame窗体中的中间，设置该标签中的图标位置和样式
		 */
		lblLight = new JLabel();
		lblLight.setHorizontalAlignment(SwingConstants.CENTER);
		lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("light.png")));
		contentPane.add(lblLight, BorderLayout.CENTER);
		
		//直接给窗体添加监听事件
		addWindowFocusListener(new WindowFocusListener() {

			@Override
			public void windowGainedFocus(WindowEvent e) {      //获得焦点
				lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("light.png")));
				lblTip.setText("JFrame窗体获得焦点，灯亮了！");
			}

			@Override
			public void windowLostFocus(WindowEvent e) {        //失去焦点
				lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("dark.png")));
				lblTip.setText("JFrame窗体失去焦点，灯灭了！");
			}
			
		});
		
	}

}

窗体状态事件

在这里插入图片描述
在java中，用WindowStateListener来监听窗体的状态事件（它是一个接口，只有一个方法）

窗体事件类提供了两个方法，可以分别捕获以前的状态getOldState、现在的状态getNewState

两个方法的返回值都是一个int的值

package forms_state_event;

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

import javax.swing.*;
import javax.swing.border.*;

public class Forms_State extends JFrame {
	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					Forms_State frame = new Forms_State();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public Forms_State() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 300, 300);
		
		addWindowStateListener(new WindowStateListener() {

			@Override
			public void windowStateChanged(WindowEvent e) {
				int oldState = e.getOldState();      //窗体以前的状态
				int newState = e.getNewState();      //窗体选中的状态
				String from = "";
				switch(oldState) {
				case Frame.NORMAL:                   //窗体处于正常化
					from = "正常化";
					break;
				case Frame.MAXIMIZED_BOTH:           //窗体处于最大化
					from = "最大化";
					break;
				default:                             //窗体处于最小化
					from = "最小化";
				}
				
				String to = "";
				switch(newState) {
				case Frame.NORMAL:                   //窗体处于正常化
					to = "正常化";
					break;
				case Frame.MAXIMIZED_BOTH:           //窗体处于最大化
					to = "最大化";
					break;
				default:                             //窗体处于最小化
					to = "最小化";
				}
				System.out.println(from + "--->" + to);
			}
			
		});
	}

}

窗体有了正常化、最大化，但是窗体最小化并没有一个确切的常量，所以这里用default
这个例子充分展示了窗体状态监听的使用方式，用到了两个常量：Frame.NORMAL（窗体处于正常化）和Frame.MAXIMIZED_BOTH（窗体处于最大化）

窗体事件

窗体事件涵盖了很多可以触发的事件，在java中，使用WindowListener监听窗体事件（它是一个接口，其抽象方法有7个）
在这里插入图片描述
现在要给窗体创建监听事件，这个监听事件可以直接写成一个匿名内部类，也可以单独写成一个类
我们在这里创建一个成员内部类

package forms_event;

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

import javax.swing.*;
import javax.swing.border.*;

public class Forms extends JFrame {
	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					Forms frame = new Forms();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public Forms() {
		//setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);     //关闭窗体时 释放窗体资源
		setBounds(100, 100, 300, 300);
		
		addWindowListener(new MyWindowListener());
	}
	
	class MyWindowListener implements WindowListener{

		@Override
		public void windowOpened(WindowEvent e) {       //窗体打开
			System.out.println("窗体被打开！");
		}

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

		@Override
		public void windowClosed(WindowEvent e) {      //窗体已被关闭  
			System.out.println("窗体已经被关闭了！");        //EXIT_ON_CLOSE 可能无法触发此方法
		}

		@Override
		public void windowIconified(WindowEvent e) {
			System.out.println("窗体被最小化！");
		}

		@Override
		public void windowDeiconified(WindowEvent e) {
			System.out.println("窗体恢复正常大小！");
		}

		@Override
		public void windowActivated(WindowEvent e) {       //窗体激活
			System.out.println("窗体被激活！");
		}

		@Override
		public void windowDeactivated(WindowEvent e) {     //窗体失去激活状态
			System.out.println("窗体失去激活！");
		}
		
	}

}

当我们打开一个窗体时，首先会激活这个窗体，于是就触发了这个方法（窗体首先被激活，然后再被打开）
窗体最小化，就是失去激活（我们现在操作不了它了）；再点回来，窗体重新被激活；
点击关闭窗体，不会失去激活，但是会windowClosing（将要关闭），已经被关闭（windowClosed）不会触发；
注意：
dispose_on_close：关闭窗体时释放窗体资源（窗体不存在，但是程序并没有停），这个情况下，窗体关闭之前会失去激活，最后窗体被彻底关闭
exit_on_close：关闭窗体时同时停止程序
另外，全屏操作不会触发任何方法

选项事件

在这里插入图片描述
在java中，用ItemListener来监听选项事件（它是一个接口，有一个抽象方法）
用到这个监听的常用组件有三个：下拉列表框、复选框、单选框。同一种监听可以用在不同组件上

选项事件类提供了两个常用的方法：
object getItem()返回选中的对象（通常用在下拉列表框上）
int getStateChange()返回选中的状态（此方法用于复选框和单选框上）
在这里插入图片描述

package option_event;

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

import javax.swing.*;
import javax.swing.border.*;

public class Option extends JFrame {
	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					Option frame = new Option();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public Option() {
		setTitle("展示组件");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 307, 194);
		
		Container contentPane = getContentPane();          //获取窗体容器
		JPanel leftPanel = new JPanel();                   //创建左侧面板
		contentPane.add(leftPanel, BorderLayout.WEST);     //放入容器西部区域
		leftPanel.setLayout(new BorderLayout());           //左侧面板使用边界布局
		
		JLabel titleLabel = new JLabel("选择要显示的组件");
		leftPanel.add(titleLabel, BorderLayout.NORTH);     //标签放入左侧面板北部区域
		
		String items[] = {"全部显示", "复选框", "单选按钮"};      //创建下拉列表框数组
		JComboBox comboBox = new JComboBox(items);         //创建下拉列表框,使用items作为显示值
		
		JPanel tmpPanel = new JPanel();                    //临时面板，为了避免下拉列表框被边界布局拉扯变形
		tmpPanel.add(comboBox);                            //下拉列表框放入临时面板中
		leftPanel.add(tmpPanel, BorderLayout.CENTER);      //临时面板放入左侧面板中部区域
		
		JPanel rightPanel = new JPanel();                  //创建右侧面板
		rightPanel.setBorder(new LineBorder(Color.black)); //右侧面板使用黑色线边框
		contentPane.add(rightPanel, BorderLayout.CENTER);  //右侧面板放入容器中部区域
		
		JCheckBox check = new JCheckBox("复选框");            //复选框
		rightPanel.add(check);	
		JRadioButton radio = new JRadioButton("单选按钮");    //单选按钮
		rightPanel.add(radio);
		
		comboBox.addItemListener(new ItemListener() {

			@Override
			public void itemStateChanged(ItemEvent e) {
				String itemName = e.getItem().toString();   //获取下拉列表中选中的字符串类型值
				switch(itemName) {
				case "复选框":
					check.setVisible(true);                 //复选框可见
					radio.setVisible(false);                //单选框不可见
					break;
				case "单选按钮":
					check.setVisible(false);                //复选框不可见
					radio.setVisible(true);                 //单选框可见
					break;
				default:
					check.setVisible(true);                 //复选框可见
					radio.setVisible(true);                 //单选框可见
				}
				
			}
			
		});
		
		check.addItemListener(new MyItemListener());
		radio.addItemListener(new MyItemListener());	
	}
	
	class MyItemListener implements ItemListener{

		@Override
		public void itemStateChanged(ItemEvent e) {
			//强制地转换成 复选框和单选按钮的共同父类：抽象按钮
			AbstractButton btn = (AbstractButton)e.getSource();   //返回触发选项事件的组件
			int state = e.getStateChange();    //获取组件的选中状态
			switch(state) {
			case ItemEvent.SELECTED:
				System.out.println(btn.getText() + "选中");
				break;
			case ItemEvent.DESELECTED:
				System.out.println(btn.getText() + "取消");
			}
		}
		
	}

}

复选框和单选按钮也可以添加选项事件，让他们输出选中和未选中的状态
我们在这里创建内部类MyItemListener，去继承ItemListener
复选框和单选按钮都有选中和未选中的状态，所以我们先去获取它们各自的选中状态
用ItemEvent的getSource这个方法（它的返回值是object类型的，所以要做强制转换），获取触发此事件的组件（因为单选框和复选框是两个完全不同的组件），可以去调用这两个组件的一个父类：AbstractButton这样一个类，然后可以输出它的文本值btn.getText()