• 第十八章：Swing自述

    18.1 Swing概述

    18.2：Swing常用窗体

    18.2.1：JFrame窗体

    1. package eightth;
    2.  
    3. import java.awt.*; //导入AWT包
    4. import javax.swing.*; //导入Swing包
    5.  
    6. public class JFreamTest {
    7. 	public static void main(String args[]) { // 主方法
    8. 		JFrame jf = new JFrame();// 创建窗体对象
    9. 		jf.setTitle("创建一个JFrame窗体");// 设置窗体标题
    10. 		Container container = jf.getContentPane(); // 获取主容器
    11. 		JLabel jl = new JLabel("这是一个JFrame窗体");// 一个文本标签
    12. 		jl.setHorizontalAlignment(SwingConstants.CENTER); // 使标签上的文字居中
    13. 		container.add(jl); // 将标签添加到主容器中
    14. 		jf.setSize(300, 150); // 设置窗体宽高
    15. 		jf.setLocation(320, 240);// 设置窗体在屏幕中出现的位置
    16. 		jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 关闭窗体则停止程序
    17. 		jf.setVisible(true); // 让窗体展示出来
    18. 	}
    19. }
    20. //例题18.1

    18.2.2：JDialog对话框

    1. package eightth;
    2. import java.awt.*;
    3. import java.awt.event.*;
    4. import javax.swing.*;
    5.  
    6. class MyJDialog extends JDialog { // 自定义对话框类，继承JDialog
    7. 	public MyJDialog(MyFrame frame) {
    8. 		// 调用父类构造方法，第一个参数是父窗体，第二个参数是窗体标题，第三个参数表示阻塞父窗体
    9. 		super(frame, "第一个JDialog窗体", true);
    10. 		Container container = getContentPane(); // 获取主容器
    11. 		container.add(new JLabel("这是一个对话框")); // 在容器中添加标签
    12. 		setBounds(120, 120, 100, 100); // 设置对话框窗体在桌面显示的坐标和大小
    13. 	}
    14. }
    15.  
    16. public class MyFrame extends JFrame { // 自定义窗体类，继承JFrame
    17. 	public MyFrame() {// 窗体的构造方法
    18. 		Container container = getContentPane(); // 获得窗体主容器
    19. 		container.setLayout(null); // 容器使用绝对布局
    20. 		JButton bl = new JButton("弹出对话框"); // 创建一个按钮
    21. 		bl.setBounds(10, 10, 100, 21); // 定义按钮在容器中的坐标和大小
    22. 		bl.addActionListener(new ActionListener() { // 为按钮添加点击事件
    23. 			public void actionPerformed(ActionEvent e) {// 点击事件触发的方法
    24. 				MyJDialog dialog = new MyJDialog(MyFrame.this); // 创建MyJDialo对话框
    25. 				dialog.setVisible(true); // 使对话框可见
    26. 			}
    27. 		});
    28. 		container.add(bl); // 将按钮添加到容器中
    29. 		setSize(200, 200); // 窗体的宽高
    30. 		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 关闭窗体则停止程序
    31. 		setVisible(true); // 使窗体可见
    32. 	}
    33.  
    34. 	public static void main(String args[]) {
    35. 		new MyFrame();
    36. 	}
    37. }
    38. //例题18.2

    18.2.3：JOptionPane小型对话框

    1.通知框

    1. package eightth;
    2.  
    3. import javax.swing.Icon;
    4. import javax.swing.ImageIcon;
    5. import javax.swing.JButton;
    6. import javax.swing.JOptionPane;
    7.  
    8. public class Demo {
    9. 	public static void main(String[] args) {
    10. 		Object o[] = {new JButton("是的"), new JButton("再想想")};   // 按钮对象的Object数组
    11. 		Icon icon = new ImageIcon("src/注意.png");                      // 获取图标对象
    12. 		JOptionPane.showOptionDialog(null, "你做好准备了吗？", "注意了！",
    13. 		JOptionPane.DEFAULT_OPTION, JOptionPane.DEFAULT_OPTION, icon, o, null);
    14.  
    15. 	}
    16. }
    17. //例题18.3

     2.确认框

    1. package eightth;
    2. import javax.swing.JOptionPane;
    3. public class Demo4 {
    4. 	public static void main(String[] args) {
    5. 		int answer = JOptionPane.showConfirmDialog(null,
    6. 				"确定离开吗？",
    7. 				"标题",
    8. 				JOptionPane.YES_NO_OPTION);
    9. 	}
    10. }
    11.  
    12. //例题18.4
    1. package eightth;
    2. import javax.swing.JOptionPane;
    3. public class Demo4 {
    4. 	public static void main(String[] args) {
    5. 		int answer = JOptionPane.showConfirmDialog(null,
    6. 				"确定离开吗？",
    7. 				"标题",
    8. 				JOptionPane.YES_NO_CANCEL_OPTION);
    9. 	}
    10. }
    11.  
    12. //例题18.4

     

    3.输入框

    1. package eightth;
    2.  
    3.  
    4. import javax.swing.JOptionPane;
    5.  
    6. public class Demo5 {
    7. 	public static void main(String[] args) {
    8. 		String name = JOptionPane.showInputDialog(null, "请输入您的姓名");
    9. 	}
    10. }
    11. //例题18.5

    4.通知框

    1. package eightth;
    2.  
    3.  
    4. import javax.swing.JOptionPane;
    5.  
    6. public class Demo6 {
    7. 	public static void main(String[] args) {
    8. 		JOptionPane.showMessageDialog(null, 
    9. 				"您与服务器断开了连接", 
    10. 				"发生错误", 
    11. 				JOptionPane.ERROR_MESSAGE);
    12. 	}
    13. }
    14. //例题18.6

    18.3：常用布局管理器 

    18.3.1：null绝对布局

    18.3.2：BorderLayout边界布局管理器

    1. package eightth;
    2.  
    3. import java.awt.*;
    4. import javax.swing.*;
    5. public class AbsolutePosition extends JFrame {
    6.     public AbsolutePosition() {
    7.         setTitle("本窗体使用绝对布局");               // 窗体标题
    8.         setLayout(null);                              // 使用null布局
    9.         setBounds(0, 0, 300, 150);                  // 设置窗体的坐标与宽高
    10.         Container c = getContentPane();            // 获取主容器
    11.         JButton b1 = new JButton("按钮1");          // 创建按钮
    12.         JButton b2 = new JButton("按钮2"); 
    13.         b1.setBounds(10, 30, 80, 30);               // 设置按钮的位置与大小
    14.         b2.setBounds(60, 70, 100, 20);
    15.         c.add(b1); // 将按钮添加到容器中
    16.         c.add(b2);
    17.         setVisible(true);                               // 使窗体可见
    18.       
    19.         setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);   // 关闭窗体则停止程序
    20.     }
    21.     public static void main(String[] args) {
    22.         new AbsolutePosition();
    23.     }
    24. }
    25.  
    26. //例题18.7

     

    1. package eightth;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class FlowLayoutPosition extends JFrame {
    5.     public FlowLayoutPosition() {
    6.         setTitle("本窗体使用流布局管理器");       // 设置窗体标题
    7.         Container c = getContentPane();
    8.         // 窗体使用流布局，组件右对齐，组件之间的水平间隔为10像素，垂直间隔10像素
    9.         setLayout(new FlowLayout(FlowLayout.RIGHT, 10, 10));
    10.         for (int i = 0; i < 10; i++) {        // 在容器中循环添加10个按钮
    11.             c.add(new JButton("button" + i));
    12.         }
    13.         setSize(300, 200);                    // 设置窗体大小
    14.        
    15.         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); // 关闭窗体则停止程序
    16.         setVisible(true);                    // 设置窗体可见
    17.     }
    18.     public static void main(String[] args) {
    19.         new FlowLayoutPosition();
    20.     }
    21. }
    22.  
    23.  
    24. //例题18.8

    1. package eightth;
    2.  
    3. import java.awt.*;
    4. import javax.swing.*;
    5.  
    6. public class BorderLayoutPosition extends JFrame {
    7. 	public BorderLayoutPosition() {
    8. 		setTitle("这个窗体使用边界布局管理器");
    9. 		Container c = getContentPane(); // 获取主容器
    10. 		setLayout(new BorderLayout()); // 容器使用边界布局
    11. 		JButton centerBtn = new JButton("中");
    12. 		JButton northBtn = new JButton("北");
    13. 		JButton southBtn = new JButton("南");
    14. 		JButton westBtn = new JButton("西");
    15. 		JButton eastBtn = new JButton("东");
    16. 		c.add(centerBtn, BorderLayout.CENTER); // 中部添加按钮
    17. 		c.add(northBtn, BorderLayout.NORTH); // 北部添加按钮
    18. 		c.add(southBtn, BorderLayout.SOUTH); // 南部添加按钮
    19. 		c.add(westBtn, BorderLayout.WEST); // 西部添加按钮
    20. 		c.add(eastBtn, BorderLayout.EAST); // 东部添加按钮
    21. 		setSize(350, 200); // 设置窗体大小
    22. 		setVisible(true); // 设置窗体可见
    23. 		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); // 关闭窗体则停止程序
    24. 	}
    25.  
    26. 	public static void main(String[] args) {
    27. 		new BorderLayoutPosition();
    28. 	}
    29. }
    30. //18.9

    18.3.4：GridLayout网格布局管理器

    1. package eightth;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class GridLayoutPosition extends JFrame {
    5.     public GridLayoutPosition() {
    6.         Container c = getContentPane();
    7.     	   // 设置容器使用网格布局管理器，设置7行3列的网格。组件间水平间距为5像素，垂直间距为5像素
    8.         setLayout(new GridLayout(7, 3, 5, 5));
    9.         for (int i = 0; i < 20; i++) {
    10.             c.add(new JButton("button" + i));   // 循环添加按钮
    11.         }
    12.         setSize(300, 300);
    13.         setTitle("这是一个使用网格布局管理器的窗体");
    14.         setVisible(true);
    15.         setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    16.     }
    17.     public static void main(String[] args) {
    18.         new GridLayoutPosition();
    19.     }
    20. }
    21.  
    22. //例题18.10

     

    18.4：常用面板

    18.4.1：JPanel面板

    1. package eightth;
    2.  
    3. import java.awt.BorderLayout;
    4. import java.awt.Container;
    5. import java.awt.GridLayout;
    6.  
    7. import javax.swing.BorderFactory;
    8. import javax.swing.JButton;
    9. import javax.swing.JFrame;
    10. import javax.swing.JPanel;
    11. import javax.swing.WindowConstants;
    12.  
    13. public class JPanelTest extends JFrame {
    14. 	public JPanelTest() {
    15. 		Container c = getContentPane();
    16. 		// 将整个容器设置为2行2列的网格布局,组件水平间隔10像素，垂直间隔10像素
    17. 		c.setLayout(new GridLayout(2, 2, 10, 10));
    18. 		// 初始化一个面板，此面板使用1行4列的网格布局，组件水平间隔10像素，垂直间隔10像素
    19. 		JPanel p1 = new JPanel(new GridLayout(1, 4, 10, 10));
    20. 		// 初始化一个面板，此面板使用边界布局
    21. 		JPanel p2 = new JPanel(new BorderLayout());
    22. 		// 初始化一个面板，此面板使用1行2列的网格布局，组件水平间隔10像素，垂直间隔10像素
    23. 		JPanel p3 = new JPanel(new GridLayout(1, 2, 10, 10));
    24. 		// 初始化一个面板，此面板使用2行1列的网格布局，组件水平间隔10像素，垂直间隔10像素
    25. 		JPanel p4 = new JPanel(new GridLayout(2, 1, 10, 10));
    26. 		// 给每个面板都添加边框和标题，使用BorderFactory工厂类生成带标题的边框对象
    27. 		p1.setBorder(BorderFactory.createTitledBorder("面板1"));
    28. 		p2.setBorder(BorderFactory.createTitledBorder("面板2"));
    29. 		p3.setBorder(BorderFactory.createTitledBorder("面板3"));
    30. 		p4.setBorder(BorderFactory.createTitledBorder("面板4"));
    31. 		// 在面板1中添加按钮
    32. 		p1.add(new JButton("b1"));
    33. 		p1.add(new JButton("b1"));
    34. 		p1.add(new JButton("b1"));
    35. 		p1.add(new JButton("b1"));
    36. 		// 向面板2中添加按钮
    37. 		p2.add(new JButton("b2"), BorderLayout.WEST);
    38. 		p2.add(new JButton("b2"), BorderLayout.EAST);
    39. 		p2.add(new JButton("b2"), BorderLayout.NORTH);
    40. 		p2.add(new JButton("b2"), BorderLayout.SOUTH);
    41. 		p2.add(new JButton("b2"), BorderLayout.CENTER);
    42. 		// 向面板3中添加按钮
    43. 		p3.add(new JButton("b3"));
    44. 		p3.add(new JButton("b3"));
    45. 		// 向面板4中添加按钮
    46. 		p4.add(new JButton("b4"));
    47. 		p4.add(new JButton("b4"));
    48. 		// 向容器中添加面板
    49. 		c.add(p1);
    50. 		c.add(p2);
    51. 		c.add(p3);
    52. 		c.add(p4);
    53. 		setTitle("在这个窗体中使用了面板");
    54. 		setSize(500, 300);// 窗体宽高
    55. 		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); // 关闭动作
    56. 	}
    57.  
    58. 	public static void main(String[] args) {
    59. 		JPanelTest test = new JPanelTest();
    60. 		test.setVisible(true);
    61. 	}
    62. }
    63. //例题18.11

     18.4.2：JScrollPane滚动面板

    1. package eightth;
    2.  
    3. import java.awt.Container;
    4.  
    5. import javax.swing.JFrame;
    6. import javax.swing.JScrollPane;
    7. import javax.swing.JTextArea;
    8. import javax.swing.WindowConstants;
    9.  
    10. public class JScrollPaneTest extends JFrame {
    11. 	public JScrollPaneTest() {
    12. 		Container c = getContentPane(); // 获取主容器
    13. 		// 创建文本区域组件,文本域默认大小为20行、50列
    14. 		JTextArea ta = new JTextArea(20, 50);
    15. 		// 创建JScrollPane滚动面板，并将文本域放到滚动面板中
    16. 		JScrollPane sp = new JScrollPane(ta);
    17. 		c.add(sp); // 将该面板添加到主容器中
    18. 		setTitle("带滚动条的文字编译器");
    19. 		setSize(400, 200);
    20. 		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    21. 	}
    22.  
    23. 	public static void main(String[] args) {
    24. 		JScrollPaneTest test = new JScrollPaneTest();
    25. 		test.setVisible(true);
    26. 	}
    27. }
    28. //例题18.12

    18.5:文字标签组件与图标

    18.5.1：JLabel标签

    1. package eightth;
    2.  
    3. import java.awt.Container;
    4.  
    5. import javax.swing.JFrame;
    6. import javax.swing.JLabel;
    7. import javax.swing.WindowConstants;
    8.  
    9. public class JLabelTest extends JFrame {
    10. 	public JLabelTest() {
    11. 		Container container = getContentPane();
    12. 		// 创建一个标签
    13. 		JLabel jl = new JLabel("这是一个JFrame窗体");
    14. 		container.add(jl); // 将标签添加到容器中
    15. 		setSize(200, 100); // 设置窗体大小
    16. 		// 设置窗体关闭模式
    17. 		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    18. 		setVisible(true); // 使窗体可见
    19. 	}
    20.  
    21. 	public static void main(String args[]) {
    22. 		new JLabelTest(); // 创建MyImageIcon对象
    23. 	}
    24. }
    25. //例题18.13

    18.5.2：图标的使用

    1. package eightth;
    2.  
    3. import java.awt.Container;
    4. import java.net.URL;
    5.  
    6. import javax.swing.Icon;
    7. import javax.swing.ImageIcon;
    8. import javax.swing.JFrame;
    9. import javax.swing.JLabel;
    10. import javax.swing.SwingConstants;
    11. import javax.swing.WindowConstants;
    12.  
    13. public class MyImageIcon extends JFrame {
    14. 	public MyImageIcon() {
    15. 		Container container = getContentPane();
    16. 		//创建一个标签
    17. 		JLabel jl = new JLabel("这是一个JFrame窗体", JLabel.CENTER);
    18. 		//获取图片所在的URL
    19. 		URL url = MyImageIcon.class.getResource("pic.png");
    20. 		Icon icon = new ImageIcon(url); 		//创建Icon对象
    21. 		jl.setIcon(icon); 						//为标签设置图片
    22. 		//设置文字放置在标签中间
    23. 		jl.setHorizontalAlignment(SwingConstants.CENTER);
    24. 		jl.setOpaque(true); 					//设置标签为不透明状态
    25. 		container.add(jl); 						//将标签添加到容器中
    26. 		setSize(300, 200); 						//设置窗体大小
    27. 		setVisible(true); 						//使窗体可见
    28. 		//设置窗体关闭模式
    29. 		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    30. 	}
    31. 	public static void main(String args[]) {
    32. 		new MyImageIcon(); 						//创建MyImageIcon对象
    33. 	}
    34. }
    35. //例题18.14

    18.6：按钮组件 

    18.6.1：JButton按钮

    1. package eightth;
    2.  
    3. import java.awt.*;
    4. import java.awt.event.*;
    5. import javax.swing.*;
    6.  
    7. public class JButtonTest extends JFrame {
    8. 	public JButtonTest() {
    9. 		Icon icon = new ImageIcon("src/imageButtoo.jpg"); // 获取图片文件
    10. 		setLayout(new GridLayout(3, 2, 5, 5)); // 设置网格布局管理器
    11. 		Container c = getContentPane(); // 获取主容器
    12. 		JButton btn[] = new JButton[6]; // 创建按钮数组
    13. 		for (int i = 0; i < btn.length; i++) {
    14. 			btn[i] = new JButton(); // 实例化数组中的对象
    15. 			c.add(btn[i]); // 将按钮添加到容器中
    16. 		}
    17. 		btn[0].setText("不可用");
    18. 		btn[0].setEnabled(false); // 设置按钮不可用
    19. 		btn[1].setText("有背景色");
    20. 		btn[1].setBackground(Color.YELLOW);
    21. 		btn[2].setText("无边框");
    22. 		btn[2].setBorderPainted(false); // 设置按钮边框不显示
    23. 		btn[3].setText("有边框");
    24. 		btn[3].setBorder(BorderFactory.createLineBorder(Color.RED)); // 添加红色线型边框
    25. 		btn[4].setIcon(icon); // 为按钮设置图标
    26. 		btn[4].setToolTipText("图片按钮"); // 设置鼠标悬停时提示的文字
    27. 		btn[5].setText("可点击");
    28. 		btn[5].addActionListener(new ActionListener() { // 为按钮添加监听事件
    29. 			public void actionPerformed(ActionEvent e) {
    30. 				JOptionPane.showMessageDialog(JButtonTest.this, "点击按钮"); // 弹出确认对话框
    31. 			}
    32. 		});
    33. 		setDefaultCloseOperation(EXIT_ON_CLOSE);
    34. 		setVisible(true);
    35. 		setTitle("创建不同样式的按钮");
    36. 		setBounds(100, 100, 400, 200);
    37. 	}
    38.  
    39. 	public static void main(String[] args) {
    40. 		new JButtonTest();
    41. 	}
    42. }
    43. //例题18.15package eightth;
    44.  
    45. import java.awt.*;
    46. import java.awt.event.*;
    47. import javax.swing.*;
    48.  
    49. public class JButtonTest extends JFrame {
    50. 	public JButtonTest() {
    51. 		Icon icon = new ImageIcon("src/imageButtoo.jpg"); // 获取图片文件
    52. 		setLayout(new GridLayout(3, 2, 5, 5)); // 设置网格布局管理器
    53. 		Container c = getContentPane(); // 获取主容器
    54. 		JButton btn[] = new JButton[6]; // 创建按钮数组
    55. 		for (int i = 0; i < btn.length; i++) {
    56. 			btn[i] = new JButton(); // 实例化数组中的对象
    57. 			c.add(btn[i]); // 将按钮添加到容器中
    58. 		}
    59. 		btn[0].setText("不可用");
    60. 		btn[0].setEnabled(false); // 设置按钮不可用
    61. 		btn[1].setText("有背景色");
    62. 		btn[1].setBackground(Color.YELLOW);
    63. 		btn[2].setText("无边框");
    64. 		btn[2].setBorderPainted(false); // 设置按钮边框不显示
    65. 		btn[3].setText("有边框");
    66. 		btn[3].setBorder(BorderFactory.createLineBorder(Color.RED)); // 添加红色线型边框
    67. 		btn[4].setIcon(icon); // 为按钮设置图标
    68. 		btn[4].setToolTipText("图片按钮"); // 设置鼠标悬停时提示的文字
    69. 		btn[5].setText("可点击");
    70. 		btn[5].addActionListener(new ActionListener() { // 为按钮添加监听事件
    71. 			public void actionPerformed(ActionEvent e) {
    72. 				JOptionPane.showMessageDialog(JButtonTest.this, "点击按钮"); // 弹出确认对话框
    73. 			}
    74. 		});
    75. 		setDefaultCloseOperation(EXIT_ON_CLOSE);
    76. 		setVisible(true);
    77. 		setTitle("创建不同样式的按钮");
    78. 		setBounds(100, 100, 400, 200);
    79. 	}
    80.  
    81. 	public static void main(String[] args) {
    82. 		new JButtonTest();
    83. 	}
    84. }
    85. //例题18.15

     

    18.6.2：JRadioButton单选按钮

    1. package eightth;
    2.  
    3. import javax.swing.*;
    4.  
    5. public class RadioButtonTest extends JFrame {
    6. 	public RadioButtonTest() {
    7. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    8. 		setTitle("单选按钮的使用");
    9. 		setBounds(100, 100, 240, 120);
    10. 		getContentPane().setLayout(null); // 设置绝对布局
    11. 		JLabel lblNewLabel = new JLabel("请选择性别：");
    12. 		lblNewLabel.setBounds(5, 5, 120, 15);
    13. 		getContentPane().add(lblNewLabel);
    14. 		JRadioButton rbtnNormal = new JRadioButton("男");
    15. 		rbtnNormal.setSelected(true);
    16. 		rbtnNormal.setBounds(40, 30, 75, 22);
    17. 		getContentPane().add(rbtnNormal);
    18. 		JRadioButton rbtnPwd = new JRadioButton("女");
    19. 		rbtnPwd.setBounds(120, 30, 75, 22);
    20. 		getContentPane().add(rbtnPwd);
    21. 		// 创建按钮组，把交互面板中的单选按钮添加到按钮组中
    22. 		ButtonGroup group = new ButtonGroup();
    23. 		group.add(rbtnNormal);
    24. 		group.add(rbtnPwd);
    25. 	}
    26.  
    27. 	public static void main(String[] args) {
    28. 		RadioButtonTest frame = new RadioButtonTest(); // 创建窗体对象
    29. 		frame.setVisible(true); // 使窗体可见
    30. 	}
    31. }
    32. //例题18.16

     

    18.6.3：JCheckBox

    1. package eightth;
    2.  
    3. import java.awt.Container;
    4. import java.awt.FlowLayout;
    5. import java.awt.event.ActionEvent;
    6. import java.awt.event.ActionListener;
    7.  
    8. import javax.swing.JButton;
    9. import javax.swing.JCheckBox;
    10. import javax.swing.JFrame;
    11.  
    12. public class CheckBoxTest extends JFrame {
    13. 	public CheckBoxTest() {
    14. 		setBounds(100, 100, 170, 110); // 窗口坐标和大小
    15. 		setDefaultCloseOperation(EXIT_ON_CLOSE);
    16. 		Container c = getContentPane(); // 获取主容器
    17. 		c.setLayout(new FlowLayout()); // 容器使用流布局
    18. 		JCheckBox c1 = new JCheckBox("1"); // 创建复选框
    19. 		JCheckBox c2 = new JCheckBox("2");
    20. 		JCheckBox c3 = new JCheckBox("3");
    21. 		c.add(c1); // 容器添加复选框
    22. 		c.add(c2);
    23. 		c.add(c3);
    24. 		JButton btn = new JButton("打印"); // 创建打印按钮
    25. 		btn.addActionListener(new ActionListener() { // 打印按钮动作事件
    26. 			public void actionPerformed(ActionEvent e) {
    27. 				// 在控制台分别输出三个复选框的选中状态
    28. 				System.out.println(c1.getText() + "按钮选中状态：" + c1.isSelected());
    29. 				System.out.println(c2.getText() + "按钮选中状态：" + c2.isSelected());
    30. 				System.out.println(c3.getText() + "按钮选中状态：" + c3.isSelected());
    31. 			}
    32. 		});
    33. 		c.add(btn); // 容器添加打印按钮
    34. 		setVisible(true);
    35. 	}
    36.  
    37. 	public static void main(String[] args) {
    38. 		new CheckBoxTest();
    39. 	}
    40. }
    41.  
    42. //例题18.17

     

    选中之后控制台会返回真或者假

    18.7：列表组件

    18.7.1：JComboBox下拉列表框

    1. package eightth;
    2. import java.awt.event.ActionEvent;
    3. import java.awt.event.ActionListener;
    4.  
    5. import javax.swing.JButton;
    6. import javax.swing.JComboBox;
    7. import javax.swing.JFrame;
    8. import javax.swing.JLabel;
    9.  
    10. public class JComboBoxTest extends JFrame {
    11. 	public JComboBoxTest() {
    12. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    13. 		setTitle("下拉列表框的使用");
    14. 		setBounds(100, 100, 317, 147);
    15. 		getContentPane().setLayout(null); // 设置绝对布局
    16. 		JLabel lblNewLabel = new JLabel("请选择证件：");
    17. 		lblNewLabel.setBounds(28, 14, 80, 15);
    18. 		getContentPane().add(lblNewLabel);
    19. 		JComboBox comboBox = new JComboBox(); // 创建一个下拉列表框
    20. 		comboBox.setBounds(110, 11, 80, 21); // 设置坐标
    21. 		comboBox.addItem("身份证"); // 为下拉列表中添加项
    22. 		comboBox.addItem("军人证");
    23. 		comboBox.addItem("学生证");
    24. 		comboBox.addItem("工作证");
    25. 		comboBox.setEditable(true);
    26. 		getContentPane().add(comboBox); // 将下拉列表添加到容器中
    27. 		JLabel lblResult = new JLabel("");
    28. 		lblResult.setBounds(0, 57, 146, 15);
    29. 		getContentPane().add(lblResult);
    30. 		JButton btnNewButton = new JButton("确定");
    31. 		btnNewButton.setBounds(200, 10, 67, 23);
    32. 		getContentPane().add(btnNewButton);
    33. 		btnNewButton.addActionListener(new ActionListener() { // 为按钮添加监听事件
    34. 			@Override
    35. 			public void actionPerformed(ActionEvent arg0) {
    36. 				// 获取下拉列表中的选中项
    37. 				lblResult.setText("您选择的是：" + comboBox.getSelectedItem());
    38. 			}
    39. 		});
    40. 	}
    41.  
    42. 	public static void main(String[] args) {
    43. 		JComboBoxTest frame = new JComboBoxTest(); // 创建窗体对象
    44. 		frame.setVisible(true); // 使窗体可见
    45. 	}
    46. }//例题18.18

    18.7.2：JList列表框

    1. package eightth;
    2. import java.awt.Container;
    3. import java.awt.event.*;
    4. import javax.swing.*;
    5.  
    6. public class JListTest extends JFrame {
    7. 	public JListTest() {
    8. 		Container cp = getContentPane(); // 获取窗体主容器
    9. 		cp.setLayout(null); // 容器使用绝对布局
    10. 		// 创建字符串数组，保存列表的中的数据
    11. 		String[] contents = { "列表1", "列表2", "列表3", "列表4", "列表5", "列表6" };
    12. 		JList jl = new JList<>(contents); // 创建列表，并将数据作为构造参数
    13. 		JScrollPane js = new JScrollPane(jl); // 将列表放入滚动面板
    14. 		js.setBounds(10, 10, 100, 109); // 设定滚动面板的坐标和大小
    15. 		cp.add(js);
    16. 		JTextArea area = new JTextArea(); // 创建文本域
    17. 		JScrollPane scrollPane = new JScrollPane(area); // 将文本域放入滚动面板
    18. 		scrollPane.setBounds(118, 10, 73, 80); // 设定滚动面板的坐标和大小
    19. 		cp.add(scrollPane);
    20. 		JButton btnNewButton = new JButton("确认"); // 创建确认按钮
    21. 		btnNewButton.setBounds(120, 96, 71, 23); // 设定按钮的坐标和大小
    22. 		cp.add(btnNewButton);
    23. 		btnNewButton.addActionListener(new ActionListener() { // 添加按钮事件
    24. 			public void actionPerformed(ActionEvent e) {
    25. 				// 获取列表中选中的元素，返回java.util.List类型
    26. 				java.util.List values = jl.getSelectedValuesList();
    27. 				area.setText(""); // 清空文本域
    28. 				for (String value : values) {
    29. 					area.append(value + "\n"); // 在文本域循环追加List中的元素值
    30. 				}
    31. 			}
    32. 		});
    33. 		setTitle("在这个窗体中使用了列表框");
    34. 		setSize(217, 167);
    35. 		setVisible(true);
    36. 		setDefaultCloseOperation(EXIT_ON_CLOSE);
    37. 	}
    38.  
    39. 	public static void main(String args[]) {
    40. 		new JListTest();
    41. 	}
    42. }
    43. //例题18.19

    18.8：文本组件

    18.8.1：JTextField文本框

    1. package eightth;
    2. import java.awt.*;
    3. import java.awt.event.*;
    4. import javax.swing.*;
    5. public class JTextFieldTest extends JFrame {
    6.     public JTextFieldTest() {
    7.         Container c = getContentPane();                        // 获取窗体主容器
    8.         c.setLayout(new FlowLayout());
    9.         JTextField jt = new JTextField("请点击清除按钮");      // 设定文本框初始值
    10.         jt.setColumns(20);                                       // 设置文本框长度
    11.         jt.setFont(new Font("宋体", Font.PLAIN, 20));          // 设置字体
    12.         JButton jb = new JButton("清除");
    13.         jt.addActionListener(new ActionListener() {            // 为文本框添加回车事件
    14.             public void actionPerformed(ActionEvent arg0) {
    15.                 jt.setText("触发事件");                            // 设置文本框中的值
    16.             }
    17.         });
    18.         jb.addActionListener(new ActionListener() {           // 为按钮添加事件
    19.             public void actionPerformed(ActionEvent arg0) {
    20.                 System.out.println(jt.getText());             // 输出当前文本框的值
    21.                 jt.setText("");                                // 将文本框置空
    22.                 jt.requestFocus();                            // 焦点回到文本框
    23.             }
    24.         });
    25.         c.add(jt);                                              // 窗体容器添加文本框
    26.         c.add(jb);                                               // 窗体添加按钮
    27.         setBounds(100, 100, 250, 110);
    28.         setVisible(true);
    29.         setDefaultCloseOperation(EXIT_ON_CLOSE);
    30.     }
    31.     public static void main(String[] args) {
    32.         new JTextFieldTest();
    33.     }
    34. }
    35.  
    36.  
    37. //例题18.20

    在窗体输入后控制台会输出内容

    18.8.2：JPasswordField密码框

    密码框组件由JPasswordField对象表示，其作用是吧用户输入的字符串以某种符号进行加密。

    1. package eightth;
    2.  
    3.  
    4. import javax.swing.JFrame;
    5. import javax.swing.JPanel;
    6. import javax.swing.border.EmptyBorder;
    7. import javax.swing.JLabel;
    8. import javax.swing.JOptionPane;
    9.  
    10. import java.awt.Font;
    11. import javax.swing.JTextField;
    12. import javax.swing.SwingConstants;
    13. import javax.swing.JButton;
    14. import javax.swing.JPasswordField;
    15.  
    16. import java.awt.event.ActionEvent;
    17. import java.awt.event.ActionListener;
    18. import javax.swing.ImageIcon;
    19. import java.awt.Color;
    20.  
    21. public class mima extends JFrame { // 创建一个“登录”类，并继承JFrame
    22. 	// 声明窗体中的组件
    23. 	private JPanel contentPane;
    24. 	private JPasswordField passwordField;
    25. 	private JLabel lblBanner;
    26. 	//主方法
    27. 	public static void main(String[] args) {
    28. 		mima frame = new mima(); // 创建密码对象
    29. 		frame.setVisible(true); // 使frame可视
    30. 	}
    31. 	//创建JFrame窗体
    32. 	 
    33. 	public mima() { // Login的构造方法
    34. 		setResizable(false); // 不可改变窗体大小
    35. 		setTitle("密码框"); // 设置窗体题目
    36. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
    37. 		setBounds(80, 80, 406, 289); // 设置窗体大小
    38. 		//创建JPanel面板contentPane置于JFrame窗体中，并设置面板的边距和布局
    39. 		contentPane = new JPanel();
    40. 		contentPane.setBackground(Color.WHITE);
    41. 		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));//边界
    42. 		setContentPane(contentPane);
    43. 		contentPane.setLayout(null);
    44. 		// 创建标签lblPwd置于面板contentPane中，设置标签的大小以及标签中字体的内容、样式
    45. 		JLabel lblPwd = new JLabel("密码：");
    46. 		lblPwd.setHorizontalAlignment(SwingConstants.RIGHT);
    47. 		lblPwd.setFont(new Font("幼圆", Font.PLAIN, 16));
    48. 		lblPwd.setBounds(125, 175, 54, 15);
    49. 		contentPane.add(lblPwd);
    50. 		//创建密码框置于面板contentPane中，设置密码框的大小
    51. 		passwordField = new JPasswordField();
    52. 		passwordField.setBounds(180, 172, 156, 21);
    53. 		contentPane.add(passwordField);
    54. 		
    55. 	}
    56. }

    18.8.3：JTextArea文本域

    1. package eightth;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class JTextAreaTest extends JFrame {
    5.     public JTextAreaTest() {
    6.         setSize(200, 100);
    7.         setTitle("定义自动换行的文本域");
    8.         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    9.         Container cp = getContentPane();                      // 获取窗体主容器
    10.         // 创建一个文本内容为“文本域”、行高和列宽均为6的文本域
    11.         JTextArea jt = new JTextArea("文本域", 6, 6); 
    12.         jt.setLineWrap(true);                                  // 可以自动换行
    13.         cp.add(jt);
    14.         setVisible(true);
    15.     }
    16.     public static void main(String[] args) {
    17.         new JTextAreaTest();
    18.     }
    19. }
    20.  
    21. //例题18.21

     18.9：表格组件

    18.9.1：创建表格

    1. package eightth;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. public class JTableDemo extends JFrame {
    5.     public static void main(String args[]) {
    6.         JTableDemo frame = new JTableDemo();
    7.         frame.setVisible(true);
    8.     }
    9.     public JTableDemo() {
    10.         setTitle("创建可以滚动的表格");
    11.         setBounds(100, 100, 240, 150);
    12.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    13.         String[] columnNames = {"A", "B"};                  // 定义表格列名数组
    14.         // 定义表格数据数组
    15.         String[][] tableValues = {{"A1", "B1"}, {"A2", "B2"}, {"A3", "B3"},
    16.                 {"A4", "B4"}, {"A5", "B5"}};
    17.         // 创建指定列名和数据的表格
    18.         JTable table = new JTable(tableValues, columnNames);
    19.         // 创建显示表格的滚动面板
    20.         JScrollPane scrollPane = new JScrollPane(table);
    21.         // 将滚动面板添加到边界布局的中间
    22.         getContentPane().add(scrollPane, BorderLayout.CENTER);
    23.     }
    24. }
    25. //例题18.22

     

    18.9.2：DefaultTableModel表格数据模型

    1. package eightth;
    2. import java.awt.*;
    3. import javax.swing.*;
    4. import javax.swing.table.*;
    5. public class SortingTable extends JFrame {
    6.     private static final long serialVersionUID = 1L;
    7.     public static void main(String args[]) {
    8.         SortingTable frame = new SortingTable();
    9.         frame.setVisible(true);
    10.     }
    11.     public SortingTable() {
    12.         setTitle("表格模型与表格");
    13.         setBounds(100, 100, 240, 150);
    14.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    15.         JScrollPane scrollPane = new JScrollPane();
    16.         getContentPane().add(scrollPane, BorderLayout.CENTER);
    17.         String[] columnNames = {"A", "B"};               // 定义表格列名数组
    18.         // 定义表格数据数组
    19.         String[][] tableValues = {{"A1", "B1"}, {"A2", "B2"}, {"A3", "B3"}}; 
    20.         // 创建指定表格列名和表格数据的表格模型
    21.         DefaultTableModel tableModel = new DefaultTableModel(tableValues, columnNames);  
    22.         JTable table = new JTable(tableModel);         // 创建指定表格模型的表格
    23.         table.setRowSorter(new TableRowSorter<>(tableModel));
    24.         scrollPane.setViewportView(table);
    25.     }
    26. }
    27. //例题18.23

    可以修改

    18.9.3：维护表格模型

    1. package eightth;
    2.  
    3. import java.awt.*;
    4. import java.awt.event.*;
    5. import javax.swing.*;
    6. import javax.swing.table.*;
    7. public class AddAndDeleteDemo extends JFrame {
    8.     private DefaultTableModel tableModel;          // 定义表格模型对象
    9.     private JTable table;                            // 定义表格对象
    10.     private JTextField aTextField;
    11.     private JTextField bTextField;
    12.     public static void main(String args[]) {
    13.         AddAndDeleteDemo frame = new AddAndDeleteDemo();
    14.         frame.setVisible(true);
    15.     }
    16.     public AddAndDeleteDemo() {
    17.         setTitle("维护表格模型");
    18.         setBounds(100, 100, 530, 200);
    19.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    20.         final JScrollPane scrollPane = new JScrollPane();
    21.         getContentPane().add(scrollPane, BorderLayout.CENTER);
    22.         String[] columnNames = {"A", "B"};          // 定义表格列名数组
    23.          // 定义表格数据数组
    24.         String[][] tableValues = {{"A1", "B1"}, {"A2", "B2"}, {"A3", "B3"}}; 
    25.         // 创建指定表格列名和表格数据的表格模型
    26.         tableModel = new DefaultTableModel(tableValues, columnNames);
    27.         table = new JTable(tableModel);                // 创建指定表格模型的表格
    28.         table.setRowSorter(new TableRowSorter<>(tableModel));     // 设置表格的排序器
    29.         // 设置表格的选择模式为单选
    30.         table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    31.         // 为表格添加鼠标事件监听器
    32.         table.addMouseListener(new MouseAdapter() {
    33.             public void mouseClicked(MouseEvent e) {         // 发生了单击事件
    34.                 int selectedRow = table.getSelectedRow();    // 获得被选中行的索引
    35.                 // 从表格模型中获得指定单元格的值
    36.                 Object oa = tableModel.getValueAt(selectedRow, 0);
    37.                 // 从表格模型中获得指定单元格的值
    38.                 Object ob = tableModel.getValueAt(selectedRow, 1);
    39.                 aTextField.setText(oa.toString());           // 将值赋值给文本框
    40.                 bTextField.setText(ob.toString());           // 将值赋值给文本框
    41.             }
    42.         });
    43.         scrollPane.setViewportView(table);
    44.         JPanel panel = new JPanel();
    45.         getContentPane().add(panel, BorderLayout.SOUTH);
    46.         panel.add(new JLabel("A："));
    47.         aTextField = new JTextField("A4", 10);
    48.         panel.add(aTextField);
    49.         panel.add(new JLabel("B："));
    50.         bTextField = new JTextField("B4", 10);
    51.         panel.add(bTextField);
    52.         JButton addButton = new JButton("添加");
    53.         addButton.addActionListener(new ActionListener() {
    54.             public void actionPerformed(ActionEvent e) {
    55.                 String[] rowValues = {aTextField.getText(),
    56.                         bTextField.getText()};              // 创建表格行数组
    57.                 tableModel.addRow(rowValues);              // 向表格模型中添加一行
    58.                 int rowCount = table.getRowCount() + 1;
    59.                 aTextField.setText("A" + rowCount);
    60.                 bTextField.setText("B" + rowCount);
    61.             }
    62.         });
    63.         panel.add(addButton);
    64.         JButton updButton = new JButton("修改");
    65.         updButton.addActionListener(new ActionListener() {
    66.             public void actionPerformed(ActionEvent e) {
    67.                 int selectedRow = table.getSelectedRow();  // 获得被选中行的索引
    68.                 if (selectedRow != -1) {                     // 判断是否存在被选中行
    69.                     // 修改表格模型当中的指定值
    70.                     tableModel.setValueAt(aTextField.getText(), selectedRow, 0); 
    71.                     // 修改表格模型当中的指定值
    72.                     tableModel.setValueAt(bTextField.getText(), selectedRow, 1); 
    73.                 }
    74.             }
    75.         });
    76.         panel.add(updButton);
    77.         JButton delButton = new JButton("删除");
    78.         delButton.addActionListener(new ActionListener() {
    79.             public void actionPerformed(ActionEvent e) {
    80.                 int selectedRow = table.getSelectedRow();  // 获得被选中行的索引
    81.                 if (selectedRow != -1)                        // 判断是否存在被选中行
    82.                     tableModel.removeRow(selectedRow);       // 从表格模型当中删除指定行
    83.             } 
    84.         });
    85.         panel.add(delButton);
    86.     }
    87. }
    88. //例题18.24

    添加

    修改

    删除

    18.10：时间监听器

    18.10.1：ActionEvent动作事件

    1. package eightth;
    2.  
    3. import java.awt.Container;
    4. import java.awt.event.ActionEvent;
    5. import java.awt.event.ActionListener;
    6.  
    7. import javax.swing.JButton;
    8. import javax.swing.JFrame;
    9. import javax.swing.WindowConstants;
    10.  
    11. public class SimpleEvent extends JFrame {
    12.  
    13. 	private JButton jb = new JButton("我是按钮，点击我");
    14.  
    15. 	public SimpleEvent() {
    16. 		setLayout(null);
    17. 		setSize(200, 100);
    18. 		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    19. 		Container cp = getContentPane();
    20. 		cp.add(jb);
    21. 		jb.setBounds(10, 10, 150, 30);
    22. 		jb.addActionListener(new jbAction());
    23. 		setVisible(true);
    24. 	}
    25.  
    26. 	class jbAction implements ActionListener {
    27. 		public void actionPerformed(ActionEvent arg0) {
    28. 			jb.setText("我被点击了");
    29. 		}
    30. 	}
    31.  
    32. 	public static void main(String[] args) {
    33. 		new SimpleEvent();
    34. 	}
    35. }
    36.  
    37. //例题18.25

    18.10.2：KeyEvent键盘事件

    1. package eightth;
    2.  
    3.  
    4. import java.awt.BorderLayout;
    5. import java.awt.EventQueue;
    6.  
    7. import javax.swing.JFrame;
    8. import javax.swing.JPanel;
    9. import javax.swing.border.EmptyBorder;
    10. import java.awt.Color;
    11. import java.awt.Component;
    12.  
    13. import javax.swing.JButton;
    14. import java.awt.Font;
    15. import javax.swing.SwingConstants;
    16. import javax.swing.border.TitledBorder;
    17. import java.awt.event.KeyAdapter;
    18. import java.awt.event.KeyEvent;
    19. import java.util.ArrayList;
    20.  
    21. import javax.swing.JTextField;
    22.  
    23. // 虚拟键盘(键盘的按下与释放)
    24.  
    25. public class KeyBoard extends JFrame { // 创建“键盘”类继承JFrame
    26. 	// 声明窗体中的成员组件
    27. 	private JPanel contentPane;
    28. 	private JTextField textField;
    29. 	private JButton btnQ;
    30. 	private JButton btnW;
    31. 	private JButton btnE;
    32. 	private JButton btnR;
    33. 	private JButton btnT;
    34. 	private JButton btnY;
    35. 	private JButton btnU;
    36. 	private JButton btnI;
    37. 	private JButton btnO;
    38. 	private JButton btnP;
    39. 	private JButton btnA;
    40. 	private JButton btnS;
    41. 	private JButton btnD;
    42. 	private JButton btnF;
    43. 	private JButton btnG;
    44. 	private JButton btnH;
    45. 	private JButton btnJ;
    46. 	private JButton btnK;
    47. 	private JButton btnL;
    48. 	private JButton btnZ;
    49. 	private JButton btnX;
    50. 	private JButton btnC;
    51. 	private JButton btnV;
    52. 	private JButton btnB;
    53. 	private JButton btnN;
    54. 	private JButton btnM;
    55. 	Color green = Color.GREEN;// 定义Color对象，用来表示按下键的颜色
    56. 	Color white = Color.WHITE;// 定义Color对象，用来表示释放键的颜色
    57.  
    58. 	ArrayList btns = new ArrayList();// 定义一个集合，用来存储所有的按键ID
    59. 	// 自定义一个方法，用来将容器中的所有JButton组件添加到集合中
    60.  
    61. 	private void addButtons() {
    62. 		for (Component cmp : contentPane.getComponents()) {// 遍历面板中的所有组件
    63. 			if (cmp instanceof JButton) {// 判断组件的类型是否为JButton类型
    64. 				btns.add((JButton) cmp);// 将JButton组件添加到集合中
    65. 			}
    66. 		}
    67. 	}
    68.  
    69. 	//主方法
    70. 	 
    71. 	public static void main(String[] args) {
    72. 		EventQueue.invokeLater(new Runnable() { // 使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
    73. 			public void run() {
    74. 				try {
    75. 					KeyBoard frame = new KeyBoard(); // 创建KeyBoard对象
    76. 					frame.setVisible(true); // 使frame可视
    77. 					frame.addButtons();// 初始化存储所有按键的集合
    78. 				} catch (Exception e) {
    79. 					e.printStackTrace();
    80. 				}
    81. 			}
    82. 		});
    83. 	}
    84.  
    85. 	// 创建JFrame窗体
    86. 	 
    87. 	public KeyBoard() { // KeyBoard的构造方法
    88. 		setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09"); // 设置窗体题目
    89. 		setResizable(false); // 不可改变窗体宽高
    90. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
    91. 		setBounds(100, 100, 560, 280); // 设置窗体的位置和宽高
    92. 		//创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
    93. 		 
    94. 		contentPane = new JPanel();
    95. 		contentPane.setBackground(Color.WHITE);
    96. 		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    97. 		setContentPane(contentPane);
    98. 		contentPane.setLayout(null);
    99. 		//创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    100. 		btnQ = new JButton("Q");
    101. 		btnQ.setBackground(white);
    102. 		btnQ.setVerticalAlignment(SwingConstants.TOP);
    103. 		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
    104. 		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    105. 		btnQ.setBounds(0, 60, 47, 45);
    106. 		contentPane.add(btnQ);
    107. 		// 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    108. 		 
    109. 		btnW = new JButton("W");
    110. 		btnW.setBackground(white);
    111. 		btnW.setVerticalAlignment(SwingConstants.TOP);
    112. 		btnW.setHorizontalAlignment(SwingConstants.LEADING);
    113. 		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    114. 		btnW.setBounds(55, 60, 49, 45);
    115. 		contentPane.add(btnW);
    116. 		// 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    117. 		 
    118. 		btnE = new JButton("E");
    119. 		btnE.setBackground(white);
    120. 		btnE.setVerticalAlignment(SwingConstants.TOP);
    121. 		btnE.setHorizontalAlignment(SwingConstants.LEADING);
    122. 		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    123. 		btnE.setBounds(110, 60, 45, 45);
    124. 		contentPane.add(btnE);
    125. 		// 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    126. 		
    127. 		btnR = new JButton("R");
    128. 		btnR.setBackground(white);
    129. 		btnR.setVerticalAlignment(SwingConstants.TOP);
    130. 		btnR.setHorizontalAlignment(SwingConstants.LEADING);
    131. 		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    132. 		btnR.setBounds(165, 60, 45, 45);
    133. 		contentPane.add(btnR);
    134. 		// 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    135. 		 
    136. 		btnF = new JButton("F");
    137. 		btnF.setBackground(white);
    138. 		btnF.setVerticalAlignment(SwingConstants.TOP);
    139. 		btnF.setHorizontalAlignment(SwingConstants.LEADING);
    140. 		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    141. 		btnF.setBounds(195, 125, 45, 45);
    142. 		contentPane.add(btnF);
    143. 		//创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    144. 		 
    145. 		btnD = new JButton("D");
    146. 		btnD.setBackground(white);
    147. 		btnD.setVerticalAlignment(SwingConstants.TOP);
    148. 		btnD.setHorizontalAlignment(SwingConstants.LEADING);
    149. 		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    150. 		btnD.setBounds(137, 125, 45, 45);
    151. 		contentPane.add(btnD);
    152.  
    153. 		btnT = new JButton("T");
    154. 		btnT.setVerticalAlignment(SwingConstants.TOP);
    155. 		btnT.setHorizontalAlignment(SwingConstants.LEADING);
    156. 		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    157. 		btnT.setBackground(white);
    158. 		btnT.setBounds(220, 60, 45, 45);
    159. 		contentPane.add(btnT);
    160.  
    161. 		btnY = new JButton("Y");
    162. 		btnY.setVerticalAlignment(SwingConstants.TOP);
    163. 		btnY.setHorizontalAlignment(SwingConstants.LEADING);
    164. 		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    165. 		btnY.setBackground(white);
    166. 		btnY.setBounds(275, 60, 45, 45);
    167. 		contentPane.add(btnY);
    168.  
    169. 		btnU = new JButton("U");
    170. 		btnU.setVerticalAlignment(SwingConstants.TOP);
    171. 		btnU.setHorizontalAlignment(SwingConstants.LEADING);
    172. 		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    173. 		btnU.setBackground(white);
    174. 		btnU.setBounds(330, 60, 45, 45);
    175. 		contentPane.add(btnU);
    176.  
    177. 		btnI = new JButton("I");
    178. 		btnI.setVerticalAlignment(SwingConstants.TOP);
    179. 		btnI.setHorizontalAlignment(SwingConstants.LEADING);
    180. 		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    181. 		btnI.setBackground(white);
    182. 		btnI.setBounds(385, 60, 45, 45);
    183. 		contentPane.add(btnI);
    184.  
    185. 		btnO = new JButton("O");
    186. 		btnO.setVerticalAlignment(SwingConstants.TOP);
    187. 		btnO.setHorizontalAlignment(SwingConstants.LEADING);
    188. 		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    189. 		btnO.setBackground(white);
    190. 		btnO.setBounds(440, 60, 46, 45);
    191. 		contentPane.add(btnO);
    192.  
    193. 		btnP = new JButton("P");
    194. 		btnP.setVerticalAlignment(SwingConstants.TOP);
    195. 		btnP.setHorizontalAlignment(SwingConstants.LEADING);
    196. 		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    197. 		btnP.setBackground(white);
    198. 		btnP.setBounds(495, 60, 45, 45);
    199. 		contentPane.add(btnP);
    200.  
    201. 		btnA = new JButton("A");
    202. 		btnA.setVerticalAlignment(SwingConstants.TOP);
    203. 		btnA.setHorizontalAlignment(SwingConstants.LEADING);
    204. 		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    205. 		btnA.setBackground(white);
    206. 		btnA.setBounds(23, 125, 45, 45);
    207. 		contentPane.add(btnA);
    208.  
    209. 		btnS = new JButton("S");
    210. 		btnS.setVerticalAlignment(SwingConstants.TOP);
    211. 		btnS.setHorizontalAlignment(SwingConstants.LEADING);
    212. 		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    213. 		btnS.setBackground(white);
    214. 		btnS.setBounds(82, 125, 45, 45);
    215. 		contentPane.add(btnS);
    216.  
    217. 		btnG = new JButton("G");
    218. 		btnG.setVerticalAlignment(SwingConstants.TOP);
    219. 		btnG.setHorizontalAlignment(SwingConstants.LEADING);
    220. 		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    221. 		btnG.setBackground(white);
    222. 		btnG.setBounds(251, 125, 45, 45);
    223. 		contentPane.add(btnG);
    224.  
    225. 		btnH = new JButton("H");
    226. 		btnH.setVerticalAlignment(SwingConstants.TOP);
    227. 		btnH.setHorizontalAlignment(SwingConstants.LEADING);
    228. 		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    229. 		btnH.setBackground(white);
    230. 		btnH.setBounds(306, 125, 45, 45);
    231. 		contentPane.add(btnH);
    232.  
    233. 		btnJ = new JButton("J");
    234. 		btnJ.setVerticalAlignment(SwingConstants.TOP);
    235. 		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
    236. 		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    237. 		btnJ.setBackground(white);
    238. 		btnJ.setBounds(361, 125, 45, 45);
    239. 		contentPane.add(btnJ);
    240.  
    241. 		btnK = new JButton("K");
    242. 		btnK.setVerticalAlignment(SwingConstants.TOP);
    243. 		btnK.setHorizontalAlignment(SwingConstants.LEADING);
    244. 		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    245. 		btnK.setBackground(white);
    246. 		btnK.setBounds(416, 125, 47, 45);
    247. 		contentPane.add(btnK);
    248.  
    249. 		btnL = new JButton("L");
    250. 		btnL.setVerticalAlignment(SwingConstants.TOP);
    251. 		btnL.setHorizontalAlignment(SwingConstants.LEADING);
    252. 		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    253. 		btnL.setBackground(white);
    254. 		btnL.setBounds(471, 125, 45, 45);
    255. 		contentPane.add(btnL);
    256.  
    257. 		btnZ = new JButton("Z");
    258. 		btnZ.setVerticalAlignment(SwingConstants.TOP);
    259. 		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
    260. 		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    261. 		btnZ.setBackground(white);
    262. 		btnZ.setBounds(39, 190, 45, 45);
    263. 		contentPane.add(btnZ);
    264.  
    265. 		btnX = new JButton("X");
    266. 		btnX.setVerticalAlignment(SwingConstants.TOP);
    267. 		btnX.setHorizontalAlignment(SwingConstants.LEADING);
    268. 		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    269. 		btnX.setBackground(white);
    270. 		btnX.setBounds(107, 190, 45, 45);
    271. 		contentPane.add(btnX);
    272.  
    273. 		btnC = new JButton("C");
    274. 		btnC.setVerticalAlignment(SwingConstants.TOP);
    275. 		btnC.setHorizontalAlignment(SwingConstants.LEADING);
    276. 		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    277. 		btnC.setBackground(white);
    278. 		btnC.setBounds(178, 190, 45, 45);
    279. 		contentPane.add(btnC);
    280.  
    281. 		btnV = new JButton("V");
    282. 		btnV.setVerticalAlignment(SwingConstants.TOP);
    283. 		btnV.setHorizontalAlignment(SwingConstants.LEADING);
    284. 		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    285. 		btnV.setBackground(white);
    286. 		btnV.setBounds(250, 190, 45, 45);
    287. 		contentPane.add(btnV);
    288.  
    289. 		btnB = new JButton("B");
    290. 		btnB.setVerticalAlignment(SwingConstants.TOP);
    291. 		btnB.setHorizontalAlignment(SwingConstants.LEADING);
    292. 		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    293. 		btnB.setBackground(white);
    294. 		btnB.setBounds(315, 190, 45, 45);
    295. 		contentPane.add(btnB);
    296.  
    297. 		btnN = new JButton("N");
    298. 		btnN.setVerticalAlignment(SwingConstants.TOP);
    299. 		btnN.setHorizontalAlignment(SwingConstants.LEADING);
    300. 		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    301. 		btnN.setBackground(white);
    302. 		btnN.setBounds(382, 190, 47, 45);
    303. 		contentPane.add(btnN);
    304.  
    305. 		btnM = new JButton("M");
    306. 		btnM.setVerticalAlignment(SwingConstants.TOP);
    307. 		btnM.setHorizontalAlignment(SwingConstants.LEADING);
    308. 		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 14));
    309. 		btnM.setBackground(white);
    310. 		btnM.setBounds(449, 190, 48, 45);
    311. 		contentPane.add(btnM);
    312. 		// 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
    313. 		 
    314. 		JPanel panel = new JPanel();
    315. 		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
    316. 		panel.setBackground(Color.WHITE);
    317. 		panel.setBounds(0, 0, 540, 45);
    318. 		contentPane.add(panel);
    319. 		panel.setLayout(new BorderLayout(0, 0));
    320.  
    321. 		// 创建文本框textField置于面板panel的中间
    322. 		 
    323. 		textField = new JTextField();
    324. 		textField.addKeyListener(new KeyAdapter() { // 文本框添加键盘事件的监听
    325. 			char word;
    326.  
    327. 			@Override
    328. 			public void keyPressed(KeyEvent e) { // 按键被按下时被触发
    329. 				word = e.getKeyChar();// 获取按下键表示的字符
    330. 				for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
    331. 					// 判断按键是否与遍历到的按键的文本相同
    332. 					if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
    333. 						btns.get(i).setBackground(green);// 将指定按键颜色设置为绿色
    334. 					}
    335. 				}
    336. 			}
    337.  
    338. 			@Override
    339. 			public void keyReleased(KeyEvent e) { // 按键被释放时被触发
    340. 				word = e.getKeyChar();// 获取释放键表示的字符
    341. 				for (int i = 0; i < btns.size(); i++) {// 遍历存储按键ID的ArrayList集合
    342. 					// 判断按键是否与遍历到的按键的文本相同
    343. 					if (String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())) {
    344. 						btns.get(i).setBackground(white);// 将指定按键颜色设置为白色
    345. 					}
    346. 				}
    347. 			}
    348. 		});
    349. 		panel.add(textField, BorderLayout.CENTER);
    350. 		textField.setColumns(10);
    351. 	}
    352. }
    353. //例题18.26

     

    18.10.3：MouseEvent鼠标事件

    1. package eightth;
    2.  
    3. import java.awt.BorderLayout;
    4. import java.awt.event.MouseEvent;
    5. import java.awt.event.MouseListener;
    6.  
    7. import javax.swing.JFrame;
    8. import javax.swing.JLabel;
    9.  
    10. public class MouseEventDemo extends JFrame { // 继承窗体类JFrame
    11.  
    12. 	public static void main(String args[]) {
    13. 		MouseEventDemo frame = new MouseEventDemo();
    14. 		frame.setVisible(true); // 设置窗体可见，默认为不可见
    15. 	}
    16.  
    17. 	// 判断按下的鼠标键，并输出相应提示 @param e 鼠标事件
    18. 	 
    19. 	private void mouseOper(MouseEvent e) {
    20. 		int i = e.getButton(); // 通过该值可以判断按下的是哪个键
    21. 		if (i == MouseEvent.BUTTON1)
    22. 			System.out.println("按下的是鼠标左键");
    23. 		else if (i == MouseEvent.BUTTON2)
    24. 			System.out.println("按下的是鼠标滚轮");
    25. 		else if (i == MouseEvent.BUTTON3)
    26. 			System.out.println("按下的是鼠标右键");
    27. 	}
    28.  
    29. 	public MouseEventDemo() {
    30. 		super(); // 继承父类的构造方法
    31. 		setTitle("鼠标事件示例"); // 设置窗体的标题
    32. 		setBounds(100, 100, 500, 375); // 设置窗体的显示位置及大小
    33. 		// 设置窗体关闭按钮的动作为退出
    34. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    35.  
    36. 		final JLabel label = new JLabel();
    37. 		label.addMouseListener(new MouseListener() {
    38. 			public void mouseEntered(MouseEvent e) {// 光标移入组件时被触发
    39. 				System.out.println("光标移入组件");
    40. 			}
    41.  
    42. 			public void mousePressed(MouseEvent e) {// 鼠标按键被按下时被触发
    43. 				System.out.print("鼠标按键被按下，");
    44. 				mouseOper(e);
    45. 			}
    46.  
    47. 			public void mouseReleased(MouseEvent e) {// 鼠标按键被释放时被触发
    48. 				System.out.print("鼠标按键被释放，");
    49. 				mouseOper(e);
    50. 			}
    51.  
    52. 			public void mouseClicked(MouseEvent e) {// 发生单击事件时被触发
    53. 				System.out.print("单击了鼠标按键，");
    54. 				mouseOper(e);
    55. 				int clickCount = e.getClickCount();// 获取鼠标单击次数
    56. 				System.out.println("单击次数为" + clickCount + "下");
    57. 			}
    58.  
    59. 			public void mouseExited(MouseEvent e) {// 光标移出组件时被触发
    60. 				System.out.println("光标移出组件");
    61. 			}
    62. 		});
    63. 		getContentPane().add(label, BorderLayout.CENTER);
    64. 		//
    65. 	}
    66.  
    67. }
    68.  
    69. //例题18.27

     

  • 相关阅读:
    常用md语法
    DNS压测工具-dnsperf的安装和使用（centos）
    Java函数式编程：三、流与函数式编程
    暑期JAVA学习（38.2）线程的生命周期
    怎么将客户引到私域？
    CDH启用kerberos 高可用运维实战
    Linux下监测网卡状态：exist、down、up link、up unplugg
    Audio2Face的工作原理
    【kubernetes】kubernetes中的Controller
    通过IP地理位置阻止网络攻击
  • 原文地址：https://blog.csdn.net/m0_73576495/article/details/134270358