Swing程序设计

GUI Graphical User Interface 图形用户界面

1.1 Swing 特点

AWT(Abstract Window Toolkits)包依赖于本地平台的窗口系统来决定组件的功能，外观，风格

依赖于本地平台的组件称为重量级组件

1.Swing 允许编程人员在跨平台时指定统一的外观和风格

2.Swing组件是轻量级组件

3.Swing可以插入外观组件

1.2Swing包

为了有效地使用Swing组件，必须了解Swing包的层次结构和继承关系，Component类、Container类和JComponent类的层次和继承关系

Java.lang.Object*

Java.awt.Component

Java.awt.Container

Javax.swing.JComponent

在Swing组件中大多数GUI组件都是Component类的直接子类或间接子类
Jcomponent类是swing组件各种特性的存放位置，这些组件的特性包括设定组件边界、GUI组件自动滚动。

顶层父类是Component和Container 所以Java关于窗口组件的编写与容器的概念相关

1.2.1 Swing的常量

• static int BOTTOM
  用于指定框底部位置的框方向常量。
• static int CENTER
  某区域的中心位置。
• static int EAST
  罗盘方向东（右）。
• static int HORIZONTAL
  水平方向。
• static int LEADING
  标识使用从左到右和从右到左的语言的文本开始边。
• static int LEFT
  用于指定框左侧位置的框方向常量。
• static int NEXT
  标识序列中的下一个方向。
• static int NORTH
  罗盘方向北（上）。
• static int NORTH_EAST
  罗盘方向东北（右上）。
• static int NORTH_WEST
  罗盘方向西北（左上）。
• static int PREVIOUS
  标识序列中前一个方向。
• static int RIGHT
  用于指定框右侧位置的框方向常量。
• static int SOUTH
  罗盘方向南（下）。
• static int SOUTH_EAST
  罗盘方向东南（右下）。
• static int SOUTH_WEST
  罗盘方向西南（左下）。
• static int TOP
  用于指定框顶部位置的框方向常量。
• static int TRAILING
  标识使用从左到右和从右到左的语言的文本结束边。
• static int VERTICAL
  垂直方向。
• static int WEST
  罗盘方向西（左）。

1.3 常用的Swing组件概述

JButton
代表Swing按钮，按钮可以带图片或者文字

JCheckBox
代表Swing的复选框组件

JComBox
代表下拉列表框，可以在下拉显示区域显示多个选项

JFrame
代表Swing的框架类

JDialog
代表Swing版本的对话框

JLabel
代表Swing中的标签组件

JRadioButton
代表Swing的单选按钮

JList
代表用户界面显示一系列条目的组件

JextField
代表文本框

JPasswordField
代表密码框

JTextArea
代表Swing中的文本区域

JOptionPane
代表Swing中的一些对话框

1.3常见窗体

窗体作为Swing的承载物 处于非常重要的位置
Swing常用的窗体包含JFrame 和JDialog

1.3.1 JFrame窗体

它是一个容器，是Swing程序中各个组件的载体
可以将它看作是这些组件的容器 开发中可以通过继承JFrame类创建一个窗体 同时为组件设置事件 该窗体有最大化最小化的特点

JFrame在程序中的语法格式如下:

JFrame jf=new JFrame(“titile”):
Container container=jf.getContentPane();

• jf: JFrame 类的对象。
• container Container 类的对象，可以使用JFrame 对象调用getContentPane()方法获取

Swing 组件的窗体通常与组件和容器相关，所以在Frame时建完成后，需要调用geContentPane()方法将窗体转换为容器，然后在容器中添加组件成设置布局，通常，这个容器用来包含和显示组件，如果需要将组件添加至容器，可以使用add方法进行设置。例如:

container.add(new JButton("按钮"):

在容器中添加组件后，也可以使用Container类的remove0方法将这些组件从容器中副除，例如

container.remove(new JButton("按钮"));

下面的实例中实现了JFrame对象创建一个窗体， 并在其中添加一个组件。

11定义-一个类继承JFrame类

//定义一个CreateJFrame0方法
public void CreateJFrame(String title){


//实例化一个JFrame对象
JFrame jf = new JFrame(title);

//获取这个容器
Container container =f.getContentPane():

//创建一个JLabel标签
JLabel  j= now JLabel("这是一个JFrame窗体"):

//使标签上的文字居中
jl.seHorizontalAlighment(SwingConstants.CENTER);

//将标签添加到容器中
container.add(jl);

//设置容器的背景颜色
container.setBackground(Color.white);

//使窗体可视
jf.setVisible(true);

//设置窗体大小
jf.setSize(200. 150);

}

public static void main(String[] args){
    
//在主方法中调用CreatesJFrame()方法

new Example.CreateJFrame(创建一个JFrame窗体"):
}

1.3.2 JDialog

• JDialog()
  创建一个没有标题并且没有指定 Frame 所有者的无模式对话框。
• JDialog(Dialog owner)
  创建一个没有标题但将指定的 Dialog 作为其所有者的无模式对话框。
• JDialog(Dialog owner, boolean modal)
  创建一个具有指定所有者 Dialog 和模式的对话框。
• JDialog(Dialog owner, String title)
  创建一个具有指定标题和指定所有者对话框的无模式对话框。
• JDialog(Dialog owner, String title, boolean modal)
  创建一个具有指定标题、模式和指定所有者 Dialog 的对话框。

public class JDialogDemo1 extends JDialog{

	public JDialogDemo1(Frame f) {
		//实例化一个JDialog类对象  指定对话框的父窗体  窗体标题  类型
		super(f,"对话框",true);
		//获取当前容器
		Container container = getContentPane();
	    //给容器添加标签
		container.add(new JLabel("这是一个对话框"));
		//设置对话框大小
		this.setSize(100, 100);
		this.setLocationRelativeTo(f);
	}
}

public class MyFrame extends JFrame {

	public MyFrame() throws HeadlessException {
		
		//调用初始化组件的方法
		init();
		// 设置空布局
		this.setLayout(null);
		// 设置修饰  禁用或启用此窗体的装饰。
		this.setUndecorated(false);
		//设置标题
		this.setTitle("窗体");
		//设置离开操作
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		//设置大小
		this.setBounds(10, 10, 600, 400);
		//设置位置 
		this.setLocationRelativeTo(null);

	}
    private void init() {
    	// 创建一个容器
    	Container container = this.getContentPane();
    	//添加标签
    	JLabel jl=new JLabel("我是一个文本");
    	//将标签居中显示              SwingConstants.CENTER  Swing窗体的显示居中
    	jl.setHorizontalAlignment(SwingConstants.CENTER);
    	//给容器添加jlable 标签
    	container.add(jl);
    	
    	//创建一个按钮组件
    	JButton jb=new JButton("弹出对话框");
    	//设置大小
    	jb.setBounds(240, 160, 100, 25);
    	//给按钮添加单击事件
    	jb.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
			   //弹出  JDialog窗体   也就是 是窗体可见
				//匿名内部类中 使用this  需要使用  类名.this   才能获得当前类对象
				new JDialogDemo1(MyFrame.this).setVisible(true);
				
			}
		});
    	//容器添加 jb  按钮组件
    	container.add(jb);
    	
	}
	public static void main(String[] args) {
		//实例化窗体对象
		new MyFrame().setVisible(true);
	}
}

1.4 标签

1.4.1 图标的定义

通过JLable类定义 它的父类为JComponent类

标签可以显示一行只读文本 ，一个图像，或者带图像的文本，但是标签不能产生任何类型的事件，只是简单的显示

• JLabel()
  创建无图像并且其标题为空字符串的 JLabel。
• JLabel(Icon image)
  创建具有指定图像的 JLabel 实例。
• JLabel(Icon image, int horizontalAlignment)
  创建具有指定图像和水平对齐方式的 JLabel 实例。
• JLabel(String text)
  创建具有指定文本的 JLabel 实例。
• JLabel(String text, Icon icon, int horizontalAlignment)
  创建具有指定文本、图像和水平对齐方式的 JLabel 实例。
• JLabel(String text, int horizontalAlignment)
  创建具有指定文本和水平对齐方式的 JLabel 实例。

1.4.1 图标的使用

图标可以放置在按钮，标签，用于描述组件的用途，支持图片文件类型进行创建，也可以适应 java.awt.Graphics类提供的功能进行创建。

方法摘要

• int getIconHeight()
  返回图标的高度。
• int getIconWidth()
  返回图标的宽度。
• void paintIcon(Component c, Graphics g, int x, int y)
  在指定位置上绘制图标。

下面代码举例

import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;

public class MyIcon implements Icon{
	//设置图标的属性
	private int  width;
	private  int  height;
	
	//定义构造方法
	public MyIcon(int width, int height) {
		super();
		this.width = width;
		this.height = height;
	}
	
    //实现paintIcon 方法   绘制图标
	@Override                      //参数为  需要绘制的组件，画笔，X，y  坐标
	public void paintIcon(Component c, Graphics g, int x, int y) {
		//绘制一个椭圆    全填充  起始坐标   结束坐标  宽高
		g.fillOval(x,y,width,height);
		
	}

	@Override
	public int getIconWidth() {
		// TODO Auto-generated method stub
		return this.width;
	}

	@Override
	public int getIconHeight() {
		// TODO Auto-generated method stub
		return this.height;
	}
	
	//主方法  
	public static void main(String[] args) {
		//实例化当前图标类对象
		MyIcon  icon=new  MyIcon(30, 30);
		//创建一个标签      设置文本    设置图标     并让文本在正中间
		JLabel  jl=new JLabel("我是一个文本",icon, SwingConstants.CENTER);
		jl.setSize(400, 300);
		//创建一个 JFrame窗口
		JFrame  jf=new JFrame("窗体测试");
		//获得窗体的容器
		Container container = jf.getContentPane();
		//为容器添加标签
		container.add(jl);
		//设置窗口可见  居中等属性
		jf.setLocation(400,200);
		jf.setSize(800,600);
		jf.setVisible(true);
		
	}
}

1.4.2 使用图片图标

ImageIcon 可以直接根据现有的图标创建一个图标
它实现了Icon接口 同时Java支持多种图片格式

一个 Icon 接口的实现，它根据 Image 绘制 Icon。可使用 MediaTracker 预载根据 URL、文件名或字节数组创建的图像，以监视该图像的加载状态。

==构造方法摘要 ==

• ImageIcon()
  创建一个未初始化的图像图标。
• ImageIcon(byte[] imageData)
  根据字节数组创建一个 ImageIcon，这些字节读取自一个包含受支持图像格式（比如 GIF、JPEG 或从 1.3 版本开始的 PNG）的图像文件。
• ImageIcon(byte[] imageData, String description)
  根据字节数组创建一个 ImageIcon，这些字节读取自一个包含受支持图像格式（比如 GIF、JPEG 或从 1.3 版本开始的 PNG）的图像文件。
• ImageIcon(Image image)
  根据图像对象创建一个 ImageIcon。
• ImageIcon(Image image, String description)
  根据图像创建一个 ImageIcon。
• ImageIcon(String filename)
  根据指定的文件创建一个 ImageIcon。
• ImageIcon(String filename, String description)
  根据指定的文件创建一个 ImageIcon。
• ImageIcon(URL location)
  根据指定的 URL 创建一个 ImageIcon。
• ImageIcon(URL location, String description)
  根据指定的 URL 创建一个 ImageIcon。

最常用的 通过创建一个对象再获得Image图像

• Image getImage()
  返回此图标的 Image。

public class MyImageIcon extends JFrame{

	public MyImageIcon() {
		//创建一个容器
		Container container = getContentPane();
	//创建一个标签  
		JLabel  jl=new  JLabel("我是标签"	,JLabel.CENTER);
		//获取图片的url       获得URL为空  
		URL url=MyImageIcon.class.getResource("image//bell.png");
		//实例化Icon对象
		Icon  icon =new ImageIcon(url);
		//为标签设置图片
		jl.setIcon(icon);
		//设置文字放置中间
		jl.setHorizontalAlignment(SwingConstants.CENTER);
		//设置标签不透明
		jl.setOpaque(true);
		//将标签添加到容器中
		container.add(jl);
		//设置窗体信息  
		setSize(600, 400);
		setTitle("窗体规范");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setLocationRelativeTo(null);
	}
	public static void main(String[] args) {
		new MyImageIcon().setVisible(true);
	}
}

1.5 布局管理器

每个组件在容器中都有他对应的具体的位置和大小，而在容器中摆放各种组件时很难判断各种组件的具体位置和大小。

布局管理器 LayoutManager提供了Swing组件安排、展示在容器中的方法及基本的布局功能。

常见的布局管理器有：

一、绝对布局 AbsoluteLayout
1.5.1 边框布局管理器(BorderLayout)

---

BorderLayout（边框布局管理器）是 Window、JFrame 和 JDialog 的默认布局管理器。

边框布局管理器将窗口分为 5个区域：North、South、East、West和Center。

其中，North 表示北，将占据面板的上方；Soufe 表示南，将占据面板的下方；East表示东，将占据面板的右侧；West 表示西，将占据面板的左侧；中间区域 Center 是在东、南、西、北都填满后剩下的区域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qbUdIPDy-1646218976040)(https://note.youdao.com/yws/res/324/CAFB9E215E5049869337A00A35C5E812)]

提示：边框布局管理器并不要求所有区域都必须有组件，如果四周的区域（North、South、East 和 West 区域）没有组件，则由 Center 区域去补充。如果单个区域中添加的不只一个组件，那么后来添加的组件将覆盖原来的组件，所以，区域中只显示最后添加的一个组件。

BorderLayout()
创建一个 Border 布局，组件之间没有间隙。
BorderLayout(int hgap,int vgap)
创建一个 Border 布局，其中 hgap 表示组件之间的横向间隔；vgap 表示组件之间的纵向间隔，单位是像素。

编码如下：

package MyLayoutManager;

import java.awt.BorderLayout;

import javax.swing.JButton;
import javax.swing.JFrame;

public class AbsolutePosition {
	public static void main(String[] agrs) {
		JFrame frame = new JFrame("BorderLayoutDemo"); // 创建Frame窗口
		frame.setSize(400, 200);

		frame.setLayout(new BorderLayout()); // 为Frame窗口设置布局为BorderLayout

		JButton button1 = new JButton("上");
		JButton button2 = new JButton("左");
		JButton button3 = new JButton("中");
		JButton button4 = new JButton("右");
		JButton button5 = new JButton("下");

		frame.add(button1, BorderLayout.NORTH);
		frame.add(button2, BorderLayout.WEST);
		frame.add(button3, BorderLayout.CENTER);
		frame.add(button4, BorderLayout.EAST);
		frame.add(button5, BorderLayout.SOUTH);

		frame.setBounds(300, 200, 600, 300);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

new BorderLayout(hgap, vgap)
h 代表水平间距 v 代表垂直间距
构造一个具有指定组件间距的边框布局

1.5.2 流式布局管理器(FlowLayout)

什么是流式布局？

FlowLayout（流式布局管理器）是 JPanel 和 JApplet 的默认布局管理器。
FlowLayout 会将组件按照从从左到右、上到下的放置规律逐行进行定位。
与其他布局管理器不同的是，FlowLayout 布局管理器不限制它所管理组件的大小，
而是允许它们有自己的最佳大小。

构造方法：

FlowLayout 布局管理器的构造方法
FlowLayout()：创建一个布局管理器，使用默认的居中对齐方式和默认 5 像素的水平和垂直间隔。
FlowLayout(int  align)：
创建一个布局管理器，使用默认 5 像素的水平和垂直间隔。
其中，align 表示组件的对齐方式，对齐的值必须是 FlowLayout.LEFT、FlowLayout.RIGHT 和 FlowLayout.CENTER，
指定组件在这一行的位置是居左对齐、居右对齐或居中对齐。
FlowLayout(int align, int hgap,int vgap)：创建一个布局管理器，其中 align 表示组件的对齐方式；

2.3 示例
使用 FlowLayout 类对窗口进行布局，向容器内添加 9 个按钮，并设置横向和纵向的间隔都为 20 像素。具体实现代码如下：

package MyLayoutManager;

import java.awt.Color;
import java.awt.FlowLayout;

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

public class Flow {

	public static void main(String[] agrs) {
		JFrame jFrame = new JFrame("FlowLayoutDemo"); // 创建Frame窗口

		JPanel jPanel = new JPanel(); // 创建面板
		JButton btn1 = new JButton("1"); // 创建按钮
		JButton btn2 = new JButton("2");
		JButton btn3 = new JButton("3");
		JButton btn4 = new JButton("4");
		JButton btn5 = new JButton("5");
		JButton btn6 = new JButton("6");
		JButton btn7 = new JButton("7");
		JButton btn8 = new JButton("8");
		JButton btn9 = new JButton("9");

		jPanel.add(btn1); // 面板中添加按钮
		jPanel.add(btn2);
		jPanel.add(btn3);
		jPanel.add(btn4);
		jPanel.add(btn5);
		jPanel.add(btn6);
		jPanel.add(btn7);
		jPanel.add(btn8);
		jPanel.add(btn9);

		// 向JPanel添加FlowLayout布局管理器，将组件间的横向和纵向间隙都设置为20像素
		jPanel.setLayout(new FlowLayout(FlowLayout.LEADING, 20, 20));
		jPanel.setBackground(Color.gray); // 设置背景色
		jFrame.add(jPanel); // 添加面板到容器
		jFrame.setBounds(300, 200, 300, 150); // 设置容器的大小
		jFrame.setVisible(true);
		jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

1.5.3 卡片布局管理器(CardLayout)

• CardLayout（卡片布局管理器）能够帮助用户实现多个成员共享同一个显示空间，并且一次只显示一个容器组件的内容。
• CardLayout 布局管理器将容器分成许多层，每层的显示空间占据整个容器的大小，但是每层只允许放置一个组件

---

构造方法：

CardLayout 的构造方法
CardLayout()：构造一个新布局，默认间隔为 0。
CardLayout(int hgap, int vgap)：创建布局管理器，并指定组件间的水平间隔（hgap）和垂直间隔（vgap）

3.3 示例

使用 CardLayout类对容器内的两个面板进行布局。其中第一个面板上包括三个按钮，第二个面板上包括三个文本框。最后调用 CardLayout 类的 show() 方法显示指定面板的内容，代码如下：

import javax.swing.*;
import java.awt.*;

public class CardLayoutDemo {
    public static void main(String[] agrs) {
        JFrame frame=new JFrame("CardLayoutDemo");    //创建Frame窗口

        JPanel p1=new JPanel();    //面板1
        JPanel p2=new JPanel();    //面板2
        JPanel cards=new JPanel(new CardLayout());    //卡片式布局的面板

        p1.add(new JButton("登录按钮"));
        p1.add(new JButton("注册按钮"));
        p1.add(new JButton("找回密码按钮"));

        p2.add(new JTextField("用户名文本框",20));
        p2.add(new JTextField("密码文本框",20));
        p2.add(new JTextField("验证码文本框",20));

        cards.add(p1,"card1");    //向卡片式布局面板中添加面板1
        cards.add(p2,"card2");    //向卡片式布局面板中添加面板2

        CardLayout cl=(CardLayout)(cards.getLayout());
        cl.show(cards,"card1");    //调用show()方法显示面板2
      //cl.show(cards,"card2");  
        frame.add(cards);
        frame.setBounds(300,200,400,200);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

在卡片布局的面板上添加面板1 面板2
并且通过卡片布局的show方法 显示另一个面板

1.5.4 网格布局管理器(GridLayout)

1.5.4.1 GridLayout

GridLayout（网格布局管理器）为组件的放置位置提供了更大的灵活性。
它将区域分割成行数（rows）和列数（columns）的网格状布局，
组件按照由左至右、由上而下的次序排列填充到各个单元格中。

提示：GridLayout 布局管理器总是忽略组件的最佳大小，
而是根据提供的行和列进行平分。
该布局管理的所有单元格的宽度和高度都是一样的。

1.5.4.2 构造方法：

• GridLayout(int rows,int cols)：创建一个指定行（rows）和列（cols）的网格布局。布局中所有组件的大小一样，组件之间没有间隔。
• GridLayout(int rows,int cols,int hgap,int vgap)：创建一个指定行（rows）和列（cols）的网格布局，并且可以指定组件之间横向（hgap）和纵向（vgap）的间隔，单位是像素。

1.5.4.3 示例

使用 GridLayout类的网格布局设计一个简单计算器。代码的实现如下：

package MyLayoutManager;

import java.awt.GridLayout;

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

public class Grid {

	public static void main(String[] args) {
		JFrame frame = new JFrame("GridLayou布局计算器");
		
		JPanel panel = new JPanel(); // 创建面板
		// 指定面板的布局为GridLayout，4行4列，间隙为5
		panel.setLayout(new GridLayout(4, 4, 5, 5));
		panel.add(new JButton("7")); // 添加按钮
		panel.add(new JButton("8"));
		panel.add(new JButton("9"));
		panel.add(new JButton("/"));
		panel.add(new JButton("4"));
		panel.add(new JButton("5"));
		panel.add(new JButton("6"));
		panel.add(new JButton("*"));
		panel.add(new JButton("1"));
		panel.add(new JButton("2"));
		panel.add(new JButton("3"));
		panel.add(new JButton("-"));
		panel.add(new JButton("0"));
		panel.add(new JButton("."));
		panel.add(new JButton("="));
		panel.add(new JButton("+"));

		frame.add(panel); // 添加面板到容器
		frame.setBounds(300, 200, 200, 150);
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

1.6 面板

面板也是一个swing容器，也可以作为容器容纳其他组件，但是必须被添加在其他容器中，swing的常见面板也包括Jpanel和JScrollPanel面板。

首先需要明白，面板也是一种容器，它也继承了java.awt.Container类。

1.6.1

Jpanel可以聚集组件进行布局，面板它也是一种容器。

JScrollPanel 面板 滚动面板
他也是一个容器 但是它只能放置一个组件 并且不能使用布局管理器

如果需要在JScrollPanel上放置多个组件 需要将多个组件 放在Jpanel面板上 然后将整个面板放在 JScrollPanel面板上

• 实例

package MyJpanel1;

import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class JScrollPanelTest extends JFrame {

	public JScrollPanelTest() {

		// 获取容器对象
		Container container = getContentPane();
		// 创建文本域组件
		JTextArea jTextArea = new JTextArea(20,40);
		// 创建滚动面板 需要将要添加的组件放进 滚动面板中
		JScrollPane sp = new JScrollPane(jTextArea);
		// 给面板添加滚动面板
		container.add(sp);

		// 设置窗体对象的一些属性
		// 设置窗体属性
	
		setSize(200,200);
		setLocationRelativeTo(null);
		setResizable(false);
		setVisible(true);
	}
	public static void main(String[] args) {
		new JScrollPanelTest();
	}

}

1.8 面板切换

在用到swing组件开发界面时，用到菜单栏时，我们心中想，我们要怎样设计，才能实现窗体的切换，注意在这里我们只出现一个窗体，于是我们可能会出现这样一种想法，通过隐藏一个窗体，然后在打开一个窗体，的方法来实现，窗体的切换，但这样做，有一个问题，这样确实可以实现窗体的切换，但是这个切换的过程中会出现窗体闪烁这种现象，通俗而言就是肉眼很容易看出是通过隐藏这种方法来实现窗体切换的，那我们要怎样才能实现，窗体不闪烁，但还是能进行窗体的切换

窗体切换的实现过程，大致思路是：我们只创建一个 frame （JFrame）窗体，然后创造多个 panel（JPanel），我们将菜单栏定义在 frame上，其他地方通过，frame.remove(panel) 和 frame.add(panel)，来实现窗体的切换，在我的方法中实际就是 panel的切换，从而实现 窗体内容的改变，下面我们通过代码，进一步了解这种方法的实现过程。

• 首页

package MyJpanel;

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

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

public class Index {

	// 创造全局变量，并且私有
	private static JFrame frame = new JFrame();

	private static JPanel panel = null;

	public Index() {

		frame = new JFrame("切换界面");
		frame.setBounds(100, 100, 1116, 790);
		frame.getContentPane().setLayout(null);

		// 使窗体不能放大
		frame.setResizable(false);

		// 使窗体在屏幕中间出现
		frame.setResizable(false);

		// 菜单栏
		// 新建一个菜单条
		JMenuBar jb = new JMenuBar();
		jb.setBounds(0, 0, 1116, 30);
		frame.getContentPane().add(jb);

		// 新建一个菜单选项
		JMenu jmenu1 = new JMenu("界面");
		jb.add(jmenu1);

		// 新建一个菜单项
		JMenuItem jm1 = new JMenuItem("界面一");

		jmenu1.add(jm1);

		JMenuItem jm2 = new JMenuItem("界面二");
		jmenu1.add(jm2);

		// 初始 panel
		panel = new JPanel();

		frame.add(panel);

		panel.setBounds(-1, 31, 1103, 718);
		panel.setLayout(null);

		JLabel label = new JLabel("首页");
		label.setFont(new Font("宋体", Font.PLAIN, 99));
		label.setBounds(356, 108, 326, 297);
		panel.add(label);

		// 关键地方来了，下面就是窗体的切换过程了。

		// 打开界面一
		jm1.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {

				frame.remove(panel);
				panel = FirstPanel.firstView();

				// 在这里，我们为什么要先frame.remove(panel)，这是因为，如果我们不是remove，
				// 而是add()话，会出现，有一些组件重合，那么就会导致我们一些功能，无法使用，所以我们要先remve掉frame当前的panel。

				// 为什么要？panel = FirstPanel.firstView();
				// 这是因为，frame添加的panel已经改变了，如果我们不重新赋值panel的话，那我们，想要再次切换时，将会remove以前的panel
				// 对frame现在添加的panel，没有任何影响，所以要重新赋值panel
			}
		});

		// 打开界面二
		jm2.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {

				frame.remove(panel);
				panel = SecondPanel.secondView();
				// 原因同上。
			}
		});

		// 使窗体可见
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

	}

	//静态方法 
	public static JFrame returnJFrame() {
		return frame;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		new Index();
	}

}

• 界面1

package MyJpanel;

import java.awt.Font;

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

public class FirstPanel {

	

		private static JPanel panel = null;
		private static JFrame frame = null;
		
		public static JPanel firstView(){
			
			//导入frame
			frame = Index.returnJFrame();
			
			panel = new JPanel();
			
			//添加新的panel
			frame.add(panel);
			
			panel.setBounds(-1, 31, 1103, 718);
			panel.setLayout(null);
			 
			JLabel label = new JLabel("界面一");
			label.setFont(new Font("宋体", Font.PLAIN, 99));
			label.setBounds(356, 108, 326, 297);
			panel.add(label);
			
			return panel;
		}
		
		
		public static void main(String[] args) {
			// TODO Auto-generated method stub

		}

	}

• 界面2

package 窗体切换;

import java.awt.Font;

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

public class SecondPanel {
	private static JPanel panel = null;
	private static JFrame frame = null;
	
	public static JPanel secondView() {
		
		//导入frame
		frame = MainFrame.returnJFrame();
		
		panel = new JPanel();
		
		//添加新的panel
		frame.add(panel);
		
		panel.setBounds(-1, 31, 1103, 718);
		panel.setLayout(null);
		 
		JLabel label = new JLabel("界面二");
		label.setFont(new Font("宋体", Font.PLAIN, 99));
		label.setBounds(356, 108, 326, 297);
		panel.add(label);
		
		return panel;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

该方法一定要保证只有一个frame，有多个panel，通过不断的remove和add来实现窗体的切换。

1.9 按钮组件

package MyButton;

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

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

import MyJpanel1.JScrollPanelTest;

public class JbuttonTest extends JFrame {

	public JbuttonTest() {

		// 获取容器对象
		Container container = getContentPane();
	    container.setLayout(new GridLayout());
		// 创建按钮
		JButton jb= new JButton("按钮1");
		jb.setEnabled(true);
		JButton jb2= new JButton("按钮2");
		JButton jb3= new JButton("按钮3");
		JButton jb4= new JButton("按钮4");
		jb2.setEnabled(true);
		jb3.setEnabled(true);
		// 给面板添加组件
		container.add(jb);
		container.add(jb2);
		container.add(jb3);
		container.add(jb4);

		//设置一个用于区别的按钮
		JButton j= new JButton("按钮-----");
		j.setHideActionText(true);//
		//设置按钮提示
		j.setToolTipText("我是一个按钮");
		//设置按钮边界不显示
		j.setBorderPainted(false);
		//添加点击事件
		j.addActionListener(new ActionListener() {
			
			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				JOptionPane.showMessageDialog(JbuttonTest.this, "你点击了按钮", "按钮点击消息框", JOptionPane.INFORMATION_MESSAGE);
			}
		});
		
		container.add(j);
		
		// 设置窗体对象的一些属性
		// 设置窗体属性

		setSize(500,500);
		setLocationRelativeTo(null);

		setVisible(true);
	}

	public static void main(String[] args) {
		new JbuttonTest();
	}

}

除此之外 还有单选框 复选框

复选框

复选框的使用十分广泛，它具有一个方块图标，外加一段描述性的文字。

但是复选框可以多选操作，每一个复选框都提供选中和不选中两种状态。

• 案例

package MyButton;

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

import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import sun.net.www.content.image.jpeg;

public class JCheckboxTest extends JFrame {

	public JCheckboxTest() {

		Container c = getContentPane();
		// 设置边界布局
		c.setLayout(new BorderLayout());
		// 创建面板
		JPanel jPanel = new JPanel();
		// 给容器添加面板
		c.add(jPanel, BorderLayout.NORTH);
		// 创建文本域
		final JTextArea jt = new JTextArea(10,30);
		// 创建滚动面板
		JScrollPane js = new JScrollPane(jt);
		// 给面板添加滚动面板
		jPanel.add(js);
		// 创建面板 用于存放 复选框
		JPanel jp2 = new JPanel();
		c.add(jp2, BorderLayout.SOUTH);
		// 窗机复选框组件
		JCheckBox j1 = new JCheckBox("复选框1");
		JCheckBox j2 = new JCheckBox("复选框2");
		JCheckBox j3 = new JCheckBox("复选框3");
		JCheckBox j4 = new JCheckBox("复选框4");
		jp2.add(j1);
		jp2.add(j2);
		jp2.add(j3);
		jp2.add(j4);

		// 添加事件
		j1.addActionListener(new ActionListener() {

			public void actionPerformed(ActionEvent e) {
				// TODO Auto-generated method stub
				jt.append("复选框1被选中");
			}
		});

		// 设置窗体对象的一些属性
		// 设置窗体属性

		setSize(500, 500);
		setLocationRelativeTo(null);

		setVisible(true);
	}

	public static void main(String[] args) {
		new JCheckboxTest();
	}

}

实现一个多选框与文本域联动的效果

2.0 列表组件

Swing提供两种列表组件，分别为下拉列表框和列表框。列表框与下拉列表框都是带有一系列项目的组件，用户可以从中选择需要的项目。列表框较下拉列表框更加直观，但是下拉列表框更加便捷美观。

2.1 下拉列表框组件

JComboBox类 是一个带条状的显示区，它具有下拉功能。在下拉列表框的右边会有一个倒三角的按钮，点击按钮，下拉框的内容会显示出来。

---

构造方法摘要

• JComboBox()
  创建具有默认数据模型的 JComboBox。
• JComboBox(ComboBoxModel aModel)
  创建一个 JComboBox，其项取自现有的 ComboBoxModel。
• JComboBox(Object[] items)
  创建包含指定数组中的元素的 JComboBox。
• JComboBox(Vector<?> items)
  创建包含指定 Vector 中的元素的 JComboBox。

初始化下拉列表框的同时也可以指定下拉列表框的内容，内容被封装到ComboBoxModel类型、数组或者Vector向量。

JComboBox 模型

在开发程序中，以般将下拉列表框中的项目封装为ComboBoxModel的情况比较多。ComboBoxModel为接口，它代表一般模型，可以自定义一个类实现该接口，然后在初始化JComboBox对象时向上转型为ComboBoxModel接口类型，但是必须实现以下两种方法:

---

• public void setSelectedItem(Object item)。

• public Object getSelectedItem()。

其中，setSelectedItem(方法用于设置下拉列表框中的选中项，getSelectedItem0方法用于返回 下拉列表框中的选中项，有了这两个方法，就可以轻松地对下拉列表框中的项目进行操作。

自定义这个类除了实现该接口之外，还可以继承AbstractListModse类，在该类中也有两个操作下拉列表框的重要方法。

• getSize(: 返回列表的长度。
• getElementAt(int index):返回指定索引处的值。

下面来看一个使用JComboBox模型的实例。

在项目中创建JomboBoxodeTest类，
使该类继承JFrame类成为窗体组件
，在类中创建拉表框，并添加到窗体中。

package MyComboBox;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.HeadlessException;

import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;

import MyButton.JCheckboxTest;

public class ComboBoxTest extends JFrame {
	//成员变量
	JComboBox jc = new JComboBox(new MyComboBox());
	JLabel jl = new JLabel("请选择地域：");

	//构造方法
	public ComboBoxTest() {
		Container c = getContentPane();
		// 设置流式布局
		c.setLayout(new FlowLayout());
		
		//设置组件属性
		jc.setSize(50, 10);
		
		//添加组件
		c.add(jl);
		c.add(jc);
		
		
		//设置窗体属性
		setSize(500, 200);
		setLocationRelativeTo(null);

		setVisible(true);
	}
	public static void main(String[] args) {
		new ComboBoxTest();
	}
}

// 外部类
class MyComboBox extends AbstractListModel implements ComboBoxModel {

	// 创建字符串项
	String item = null;
	String[] test = { "湖南", "湖北", "河南", "湖南", "湖北", "河南" };



	public Object getElementAt(int index) {
		// TODO Auto-generated method stub
		return test[index];
	}

	public void setSelectedItem(Object anItem) {

         item=(String) anItem;
	}

	public Object getSelectedItem() {
		// TODO Auto-generated method stub
		return item;
	}

	public int getSize() {
		// TODO Auto-generated method stub
		return test.length;
	}

}

2.2 列表框组件

简单的、动态内容的 JList 应用程序可以使用 DefaultListModel 类维护列表元素。此类实现 ListModel 接口，它还提供类似于 java.util.Vector 的 API。而需要自定义 ListModel 实现的应用程序可能希望子类化 AbstractListModel，它提供对管理和通知侦听器的基本支持。例如，AbstractListModel 的一个只读实现。

---

用户已经选择了列表框的某一项时，按住Shift的时候，则会全选当前项与选中项之间所有的项，
如果用户按住Ctrl并单击项的话，可以多选多个项。

---

==构造方法摘要 ==

• JList()
  构造一个具有空的、只读模型的 JList。
• JList(ListModel dataModel)
  根据指定的非 null 模型构造一个显示元素的 JList。
• JList(Object[] listData)
  构造一个 JList，使其显示指定数组中的元素。
• JList(Vector<?> listData)
  构造一个 JList，使其显示指定 Vector 中的元素。

三种数据分别是数组、Vector向量、和ListModel模型。

如直接创建：

通过一个数组创建

String [] s={"d","a","s"};
JList jl=new JList(s)；

通过向量创建：

Vector v=new Vector();
JList jl=new JList(v)；
v.add("列表1");
v.add("列表2");
v.add("列表3");

通过 ListModel模型创建，需要创建ListModel对象。

如果使用ListModel模型为参数，需要创建 ListModel对象,ListModel是对Swing包中的一个接口，提供了获取列表框属性的方法。

但是在通常情况下，为了使用户不完全实现ListModel接口中的方法，

通常自定义一个类继承实现该接口的抽象类AbstractListModel.

在这个类中提供了geElementAt()与getSize()方法

，其中getElementAt(方法代表根据项目的索引获取列表框中的值

，而getSize()方法用于获取列表框中的项目个数

---

使用第4种构造方法初始化列表框的基本方法。
在项目中创建 JListest 类，使该类维承JFrame类成为窗体组件，列表框，并添加到窗体中。

package MyList;

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

import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class JListTest extends JFrame {

	public JListTest() {

		Container c = getContentPane();
		// 设置空布局
		c.setLayout(null);
		// 创建面板
		JPanel jPanel = new JPanel();
		// 给容器添加面板
		c.add(jPanel);

		// 创建列表框
		JList jl = new JList(new MyJlist());
		// 创建滚动面板
		JScrollPane js = new JScrollPane(jl);
		//设置滚动面板大小
		js.setBounds(10, 10, 150, 150);

		// 添加组件
		c.add(js);
		// 设置窗体对象的一些属性
		// 设置窗体属性

		setSize(500, 500);
		setLocationRelativeTo(null);

		setVisible(true);
	}

	public static void main(String[] args) {
		new JListTest();
	}
}

// 外部类
// 继承了抽象类AbstractListModel
class MyJlist extends AbstractListModel {

	// 设置列表框内容
	private String[] test = { "湖南", "湖北", "河南", "湖南", "湖北", "河南" };

	public Object getElementAt(int index) {

		if (index < test.length) {
			return test[index++];
		} else {
			return null;
		}

	}

	public int getSize() {
		// TODO Auto-generated method stub
		return test.length;
	}

}

除了可以使用上面的方法外，还可以使用DefaultListModel类创建列表框，
该类扩展了AbstractListModel类，
所以也可以通过DefaultListModel对象向上转型为ListModel接口化列表框，
同时DefaultListModel提供addElement()方法将内容添加到列表框。

通过DefaultListModel类创建列表框

final String []flavors={"列表1"，"列表2"，"列表3""列表4"}；

final DefaultListModel  items=new DefaultListModel();

//实例化JList对象
final JList  jl=new  JList(items);

//循环添加数据
for(int i=0;i<4;i++){
    
    items.addElement(flavors[i]);
}

3.0 文本组件

文本框 和文本域 较简单 此处不计

3.1 密码框

JPasswordField 是一个轻量级组件，允许编辑单行文本，其视图指示键入内容，但不显示原始字符。

构造方法摘要

• JPasswordField()
  构造一个新 JPasswordField，使其具有默认文档、为 null 的开始文本字符串和为 0 的列宽度。
• JPasswordField(Document doc, String txt, int columns)
  构造一个使用给定文本存储模型和给定列数的新 JPasswordField。
• JPasswordField(int columns)
  构造一个具有指定列数的新的空 JPasswordField。
• JPasswordField(String text)
  构造一个利用指定文本初始化的新 JPasswordField。
• JPasswordField(String text, int columns)
  构造一个利用指定文本和列初始化的新 JPasswordField。

4.0 常用事件监听