Java——Swing组件与布局管理器

谁践踏了优雅 2023-06-07 08:11 12阅读 0赞

### Java——Swing组件与布局管理器 ###

*  简单框架设计：
 *  简单图形按钮控件的设计及实例：
 *   *  （1）按钮常用构造器：JButton button=new JButton();
     *  （2）按钮的模型
     *  （3）添加普通按钮
     *  （4）添加单选按钮
     *  （5）添加复选框
     *  （6）ToggleButton按钮
 *  简单文本输入组件的设计及实例：
 *   *  （1）文本域
     *  （2）密码域
     *  （3）文本区域
 *  展示类组件的设计及实例：
 *   *  （1）标签组件
     *  （2）选择组件
     *  （3）菜单组件
     *  （4）对话框的种类及用法
 *  复杂布局管理器的种类及用法
 *   *  （1）箱式布局的设计
     *  （2）网络组布局的设计
     *  （3）流布局的设计
     *  （4）边界布局的设计

--------------------

***本人是个新手，写下博客用于自我复习、自我总结。  
如有错误之处，请各位大佬指出。  
参考教材：零基础学Java***

--------------------

GUI全称为图形用户界面，主要用来为应用程序提供用户操作的图形界面。

所谓图形界面，就是利用鼠标、触控屏幕和图形化的操作接口等来操作一个软件或应用程序系统。为了帮助程序员快速地开发图形用户界面，SUM公司提供了两个包，分别为AWT和Swing。对于AWT，它是Sun公司提供的早期版本，由于该包的组件种类有限，虽然可以实现基本的GUI设计，但是却不能满足目前的GUI设计。对于Swing，它是AWT的改进版本，在AWT的基础上提供了更加丰富的部件和功能。

在Swing中，每一个组件都有3个要素：  
（1）内容：例如按钮的状态（是否被按下）、文本框内的文本等  
（2）外观：组件所表现出来的效果，例如颜色、形状等  
（3）行为：组件对事件的处理方式，接受事件后如何处理  
这三个要素的关系很复杂，所以程序员不要让一个对象具备太多的功能，这跟MVC的模式实现有关。MVC模式包括下面3个部分：  
（1）模型（M）：用于存储内容，它只关心组件的内容  
（2）视图（V）：用于实现组件的外观  
（3）控制器（C）：用于实现组件的事件处理

也就是说，模型只是负责存储内容，它并没有任何用户界面，模型只是负责处理业务逻辑，它并不关心如何显示给用户，只是为视图提供原始的数据而已。视图可以显示模型的一部分，一个模型可以有多个视图。控制器负责处理用户输入事件，例如用户单击鼠标、文本框输完后按Enter键等，这些都交给控制器来负责。如果用户拖动滚动条，那么控制器就把动作交给了视图和模型，因为随着滚动条的移动，视图和模型都在变。

# 简单框架设计： #

框架是一个界面最外围的元素，必须有框架，才能在框架上添加其他的元素。所谓框架就是窗口，查看API帮助文档可以发现表示窗口的Frame类继承于Windows类，而Windows类继承于Container类。

在AWT库中有一个Frame类与框架对应，而在Swing中与之对应的是JFrame，它是Frame的扩展，同时它也是一个容器。JFrame类不是一个简单的窗口框，由于其包含了常见的标题栏、边框等，所以也被称为窗口类。

例：利用Swing创建一个空白的框架

import javax.swing.JFrame;
    public class Swing {  //设计类
    	static final int WIDTH=300;
    	static final int HEIGHT=200;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.show(); //显示窗口
    	}
    }

其中的javax表示这是java的一个扩展包。

可以关闭窗口，是因为通过调用setDefaultCloseOperation方法做到，  
在这个方法内有4个不同的参数，也可以说是4个常量，具体如下：  
（1）DO\_NOTHING\_ON\_CLOSE:当窗口关闭时，什么也不做  
（2）DISPOSE\_ON\_CLOSE:当窗口关闭时，强制JAVA虚拟机释放创建窗口所占的资源  
（3）HIDE\_ON\_CLOSE:当窗口关闭时，实际上是将该窗口隐蔽起来了  
（4）EXIT\_ON\_CLOSE:当窗口关闭时，强制JAVA虚拟机释放程序所占用的资源

DISPOSE\_ON\_CLOSE和EXIT\_ON\_CLOSE的区别在于前者只关闭窗口就可以，后者则是关闭窗口后，就退出程序。

创建框架的其他工作：  
创建一个空框架后，接下来就是给框架设定一个标题，设置标题使用如下方法：  
public void setTitle(String title);  
上面这个是设置器，那么显然会有访问器  
public String getTitle();  
如果框架没有设置框架标题，就返回一个空的字符串。

在很多应用程序中，窗口都是位于屏幕中央，而上例中，得到的框架位于左上角，  
接下来是如何定位框架：  
在JAVA中规定屏幕的左上角顶点为原点，水平为x轴，垂直为y轴，所以屏幕左上角的坐标就是（0，0）。如果屏幕的分辨率是1024\*768像素，那么右下角的坐标就是（1024，768），而默认的框架从左上角开始，使用方法如下：  
public void setLocation(int x,int y);  
也有方法直接将框架放到屏幕中间：  
①先通过函数获得屏幕的高度和宽度  
int width=screenSize.width;  
int height=screenSize.height;  
②然后计算框架左上角的坐标  
int x=(width-WIDTH)/2;  
int y=(height-HEIGHT)/2;  
③接下来是获得屏幕screenSize方法  
Toolkit kit=Toolkit.getDefaulToolkit();  
Dimension screenSize=kit.getScreenSize();  
这样就能将框架定位到中心位置

例：

import java.awt.Dimension;
    import java.awt.Toolkit;
    import javax.swing.JFrame;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		jf.show(); //显示窗口
    	}
    }

在使用应用软件时，希望能改变框架的大小，如何对框架进行缩放？  
public void setResizable(boolean resizable)  
如果不允许用户缩放框架大小，只需将resizable设置为false，如果一个  
框架不知道是否可以缩放，可以使用以下方法看看是否可以缩放：  
boolean isResizable()

# 简单图形按钮控件的设计及实例： #

## （1）按钮常用构造器：JButton button=new JButton(); ##

这个默认的按钮有特定的大小、颜色和外观，都由模型来完成。

JButton button=new JButton(Action a);  
可以采用一个Action对象构成一个按钮，其实还可以通过指定一个按钮的字符串、按钮的图标，来创建按钮对象。

## （2）按钮的模型 ##

大多数组件的模型类，实现了一个以Model结尾的接口名字，例如按钮就实现了一个ButtonModel的接口。实现了此接口的类可以定义按钮的多种状态。在Swing库包含了一个DefaultButtonModel类，这个类就实现了ButtonModel接口，也就是按钮的默认状态。

ButtonModel接口中的方法：  
getActionCommand():同按钮相关联的动作命令字符串  
getMnemonic():按钮的快捷键  
isArmed():如果按钮被按下并且鼠标仍在按钮上则返回true  
isEnabled():如果按钮可用则返回true  
isPressed():如果按钮被按下并且鼠标按钮尚未释放则返回true  
isRollover():如果鼠标在按钮上则返回true  
isSelected():如果按钮已经被选择（用于复选框和单选按钮）则返回true

按钮模型可用于下压按钮、单选按钮、复选框、菜单项等。虽然这些组件在外观上不同，但是作为模型却是一样，所以说，JButton类实际上是一个封装类，它将视图、控制器、模型结合在一起，从而维护一个按钮对象。

## （3）添加普通按钮 ##

在Swing中，一般组件都是添加到JPanel中，然后再将JPanel组件添加到顶层窗口中。  
如：  
panel.add(button);  
Container.add(panel);

例：

import java.awt.Dimension;
    import java.awt.Panel;
    import java.awt.Toolkit;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		//创建两个按钮对象
    		JButton b1=new JButton("确定");
    		JButton b2=new JButton("取消");
    		//创建面板对象p
    		Panel p=new Panel();
    		//添加两个按钮对象到面板中
    		p.add(b1);
    		p.add(b2);
    		//添加面板p到窗口
    		jf.add(p);
    		jf.show(); //显示窗口
    	}
    }

## （4）添加单选按钮 ##

单选按钮也被称为radioButton，它通过JRadioButton类实现。在一些数据库系统软件中，会出现“性别”单选按钮，通过选择不同的单选按钮，来实现不同性别的选择。  
例：

import java.awt.BorderLayout;
    import java.awt.Dimension;
    import java.awt.Panel;
    import java.awt.Toolkit;
    
    import javax.swing.JFrame;
    import javax.swing.JRadioButton;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		//设置窗口居中
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		//创建三个按钮对象
    		JRadioButton jr1=new JRadioButton("忽略");
    		JRadioButton jr2=new JRadioButton("继续");
    		JRadioButton jr3=new JRadioButton("跳过");
    		//创建面板对象p
    		Panel p=new Panel();
    		//添加按钮对象到面板中
    		p.add(jr1);
    		p.add(jr2);
    		p.add(jr3);
    		//添加面板p到窗口
    		jf.add(p,BorderLayout.SOUTH);
    		jf.show(); //显示窗口
    	}
    }

如果没有按钮组，3个单选按钮都可以被选中。如果希望当一个单选按钮被选中时，其他的自动被置为未选中状态，那么就要使用按钮组。  
ButtonGroup group=new ButtonGroup();  
例：

import java.awt.BorderLayout;
    import java.awt.Dimension;
    import java.awt.Panel;
    import java.awt.Toolkit;
    
    import javax.swing.ButtonGroup;
    import javax.swing.JFrame;
    import javax.swing.JRadioButton;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		//设置窗口居中
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		//创建三个按钮对象
    		JRadioButton jr1=new JRadioButton("忽略");
    		JRadioButton jr2=new JRadioButton("继续");
    		JRadioButton jr3=new JRadioButton("跳过");
    		//创建单选按钮组对象
    		ButtonGroup bg=new ButtonGroup();
    		//创建面板对象p
    		Panel p=new Panel();
    		//添加单选按钮到单选按钮组对象中
    		bg.add(jr1);
    		bg.add(jr2);
    		bg.add(jr3);
    		//添加单选按钮到面板对象中
    		p.add(jr1);
    		p.add(jr2);
    		p.add(jr3);
    		//添加面板p到窗口
    		jf.add(p,BorderLayout.SOUTH);
    		jf.show(); //显示窗口
    	}
    }

## （5）添加复选框 ##

复选框使用JCheckbox类实现，它跟单选按钮的区别就是一个可以多选，一个只能单选。  
例：

import java.awt.*;
    import javax.swing.*;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		//设置窗口居中
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		//创建三个选择按钮对象
    		JCheckBox jc1=new JCheckBox("忽略");
    		JCheckBox jc2=new JCheckBox("继续");
    		JCheckBox jc3=new JCheckBox("跳过");
    		//设置对象jc1为选中状态
    		jc1.setSelected(true);
    		//创建面板对象p
    		Panel p=new Panel();
    		//添加选择按钮到面板对象中
    		p.add(jc1);
    		p.add(jc2);
    		p.add(jc3);
    		//添加面板p到窗口
    		jf.add(p,BorderLayout.SOUTH);
    		jf.show(); //显示窗口
    	}
    }

## （6）ToggleButton按钮 ##

ToggleButton按钮就是当单击按钮时，按钮会呈现被按下的状态，再单击一下，可以恢复原先状态，其使用JToggleButton类来实现。其实它的使用跟前面所有的按钮控件一样，只不过功能不同而已。  
例：

# 简单文本输入组件的设计及实例： #

## （1）文本域 ##

Label组件的出现使得应用程序的输出可以显示在窗口上，脱离了只能输出到命令窗口的尴尬。而TextField和TextArea输入组件的出现使得应用程序的输入脱离了在命令窗口输入参数的形式。对于图形用户界面来说，为了使得用户与应用程序的交互更方便，输入组件是必需的。  
文本域的构造器如下：  
JTextField textField=new JTextField();  
创建一个没有内容的文本域。  
JTextField textField=new JTextField(String str);  
创建一个有str内容的文本域。  
JTextField textField=new JTextField(int columns);  
创建一个有columns列的文本域。

把一个文本域添加到窗口的步骤，首先是将文本域添加到一个面板中，再将这个面板添加到容器中。  
例：

## （2）密码域 ##

密码域一般用在登陆窗口等地方。Swing类库中使用JPasswordField类实现密码域，它的作用就是让所输入的内容以"\*"形式出现，这样就不会看到用户的密码了。  
例：

## （3）文本区域 ##

文本区域输入组件TextArea与文本域输入组件TextField一样，都是继承于类TextComponent，在具体显示时文本区域相当于多行文本域，使用JTextArea类实现，它的构造器：  
JTextArea textarea=new JTextArea(int x,int y);  
创建一个x行y列的文本区域。  
JTextArea textarea=new JTextArea(String str);  
创建一个有初始文本str的文本区域。

如果文本过长，超过了显示范围，会把多余的剪掉，可通过下面的方法自动换行，以保证多余文本不会被剪掉。textArea.setLineWrap(true);

例：

# 展示类组件的设计及实例： #

## （1）标签组件 ##

标签组件的设计非常简单，通过JLabel类实现。下面是构造器：  
JLabel jl=new JLabel();  
创建一个空的标签对象  
JLabel jl=new JLabel(String str);  
创建一个有字符串str的标签对象  
JLabel jl=new JLabel(String str,constant Location);  
创建一个带有字符串的标签，并且能够设定内容的对齐方式。  
对齐方式有4种，LEFT,RIGHT,CENTER,NORTH  
例：

## （2）选择组件 ##

选择组件有很多种，这里主要讲述组合列表框，也就是下拉列表框，它使用JComboBox类实现。  
例：

## （3）菜单组件 ##

菜单的设计是每个窗体必须要注意的，因为设计好的菜单，可以让使用者直观地了解系统的功能。  
例：

import java.awt.*;
    import javax.swing.*;
    public class Swing {  //创建一个顶层框架类
    	static final int WIDTH=1000;
    	static final int HEIGHT=700;
    	public static void main(String args[]){ 
    		JFrame jf=new JFrame();
    		jf.setSize(WIDTH,HEIGHT); //设置对象大小
    		//关于窗口的退出处理
    		jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		jf.setTitle("学生管理系统");
    		Toolkit kit=Toolkit.getDefaultToolkit();
    		Dimension screenSize=kit.getScreenSize();
    		//获取屏幕的宽度和高度
    		int width=screenSize.width;
    		int height=screenSize.height;
    		//设置窗口居中
    		int x=(width-WIDTH)/2;
    		int y=(height-HEIGHT)/2;
    		jf.setLocation(x,y);
    		//创建菜单栏条对象
    		JMenuBar menubar1=new JMenuBar();
    		//设置窗口对象的菜单栏
    		jf.setJMenuBar(menubar1);
    		//创建菜单对象
    		JMenu menu1=new JMenu("文件");
    		JMenu menu2=new JMenu("视图");
    		JMenu menu3=new JMenu("编辑");
    		JMenu menu4=new JMenu("帮助");
    		//添加菜单到工具栏对象
    		menubar1.add(menu1);
    		menubar1.add(menu2);
    		menubar1.add(menu3);
    		menubar1.add(menu4);
    		//创建菜单项对象
    		JMenuItem item1=new JMenuItem("打开");
    		JMenuItem item2=new JMenuItem("保存");
    		JMenuItem item3=new JMenuItem("打印");
    		JMenuItem item4=new JMenuItem("退出");
    		//添加菜单项到菜单对象menu1中
    		menu1.add(item1);
    		menu1.add(item2);
    		menu1.addSeparator(); //添加间隔条到菜单
    		menu1.add(item3);
    		menu1.addSeparator(); //添加间隔条到菜单
    		menu1.add(item4);
    		jf.show(); //显示窗口
    	}
    }

## （4）对话框的种类及用法 ##

对于选项对话框，Swing提供了一个很方便的类JOptionPane，该类能够让程序员不需要编写代码，就可以生成一个对话框。其主要提供了一些简单的对话框，用于收集用户的简单信息。  
JOptionPane类有4个静态的方法，下面列出这些简单的对话框：  
showMessageDialog:显示一条信息并且等待用户单击OK  
showConfirmDialog:显示一条信息并且得到确认  
showOptionDialog:显示一条信息并且得到用户在一组选项中选择  
showInputDialog:显示一条信息并且得到用户的一行输入

一个典型的对话框主要包括以下几个部分：  
一个图标、一条消息、一个或多个选项按钮、对话框标题

对于对话框的消息类型主要有下列5种：  
ERROR\_MESSAGE  
INFORMATION\_MESSAGE  
WARNING\_MESSAGE  
QUESTION\_MESSAGE  
PLAIN\_MESSAGE

可以指定一条消息显示在对话框上，该消息可以是字符串、图标、一个用户界面组件或者其他对象。下面列出各种消息对象的显示方式：  
String:绘制该字符串  
Icon:显示该图标  
Component:显示该组件  
Object\[\]:逐一显示每个对象，依次叠加  
其他对象：调用toString()方法，显示相应的结果字符串

调用showMessageDialog和showInputDialog时，只能得到标准按钮，分别是OK和OK/CANCEL。而调用showConfirmDialog时，可以根据不同的需要，  
选择如下4种选项类型中的一种：  
DEFAULT\_OPTION  
YES\_NO\_OPTION  
YES\_NO\_CANCEL\_OPTION  
OK\_CANCEL\_OPTION

例：

import javax.swing.*;
    public class Swing {  //创建一个顶层框架类
    	public static void main(String args[]){ 
    		JOptionPane.showConfirmDialog(null,"这是错误信息！",
    		"这是错误信息！",JOptionPane.YES_NO_CANCEL_OPTION);
    	}
    }

创建一个对话框不难，关键是当用户选择按钮时，系统能区分这个动作。通常系统会返回一个整数以区分不同的动作，整数值从0开始，  
例如：YES\_NO\_OPTION中，0表示YES，1表示NO

# 复杂布局管理器的种类及用法 #

## （1）箱式布局的设计 ##

箱式布局比GridLayout布局要灵活得多，这个也是它比较实用的地方。Swing提供的BOX类就是箱式布局类，它的默认布局管理器就是BoxLayout，在箱式布局管理器中包括了两种箱子：一种是水平箱，另外一种是垂直箱。  
创建一个水平箱：  
Box horBox=Box.createHorizontalBox();  
创建一个垂直箱：  
Box verBox=Box.createVerticalBox();  
创建好箱子后，就可以像添加其他组件一样，添加控件，代码如下：  
horBox.add(okButton);  
verBox.add(cancelButton);  
两种箱子的区别在于组件的排列顺序上，水平箱是按照从左到右的顺序排列，而垂直箱按照从上到下的顺序排列。对于箱式布局管理器，最关键的就是每个组件的3个尺寸：  
首选尺寸：组件被显示时的宽度和高度  
最大尺寸：组件能显示的最大宽度和高度  
最小尺寸：组件被显示的最小宽度和最小高度

水平箱式布局管理器中组件排列的几个重点：  
①计算最高组件的最大高度，尝试把所有的组件都增加到这个高度。如果有些组件不能达到这个高度，那么在Y轴上对齐要通过"getAlignmentY"方法得到，该方法返回一个介于0（按顶部对齐）和1（按底部对齐）之间的浮点数。组件的默认值时0.5，也就是中线对齐。  
②得到每个组件的首选宽度，然后把所有的首选宽度合计起来。  
③如果首选宽度总和小于箱的宽度，那么所有的组件都会相应的延伸，直到适应这个箱子的宽度。组件从左到右排列，并且相邻两个组件之间没有多余的空格。

箱式布局组件之间没有空隙，那么就要通过一个称为填充物的组件来提供空隙。箱式布局管理器提供了3种填充物：支柱、固定区、弹簧。

例：

import java.awt.*;
    import javax.swing.*;
    public class Swing {  
    	public static void main(String args[]){  //主方法
    		BoxLayoutFrame frame1=new BoxLayoutFrame();
    		//设置关闭方法
    		frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		//显示窗口
    		frame1.show();
    	}
    }
    class BoxLayoutFrame extends JFrame{  //创建一个顶层框架类
    	private static final int WIDTH=300;
    	private static final int HEIGHT=200;
    	public BoxLayoutFrame(){ 
    		setTitle("箱式布局管理器");
    		setSize(WIDTH,HEIGHT);
    		Container con=getContentPane();
    		//创建标签对象和文本输入框对象
    		JLabel label1=new JLabel("姓名:");
    		JTextField textField1=new JTextField(10);
    		//设置对象输入的最大字符
    		textField1.setMaximumSize(textField1.getPreferredSize());
    		//创建和设置对象
    		Box hbox1=Box.createHorizontalBox();
    		hbox1.add(label1);
    		hbox1.add(Box.createHorizontalStrut(20));
    		hbox1.add(textField1);
    		//创建标签对象和文本输入框对象
    		JLabel label2=new JLabel("密码:");
    		JPasswordField jp=new JPasswordField(10);
    		jp.setMaximumSize(jp.getPreferredSize());
    		//创建和设置对象
    		Box hbox2=Box.createHorizontalBox();
    		hbox2.add(label2);
    		hbox2.add(Box.createHorizontalStrut(20));
    		hbox2.add(jp);
    		//创建两个按钮对象
    		JButton button1=new JButton("确定");
    		JButton button2=new JButton("取消");
    		//创建和设置对象
    		Box hbox3=Box.createHorizontalBox();
    		hbox3.add(button1);
    		hbox3.add(button2);
    		Box vbox=Box.createVerticalBox();
    		vbox.add(hbox1);
    		vbox.add(hbox2);
    		vbox.add(Box.createVerticalGlue());
    		vbox.add(hbox3);
    		con.add(vbox,BorderLayout.CENTER);
    	}
    }

## （2）网络组布局的设计 ##

网络组布局管理器是一种很先进的布局管理器，通过网格的划分，可看到每个组件都占据一个网格，也可以一个组件占据几个网格。如果要采用网格组布局管理器，一般来说可以采用下列步骤：  
①创建一个GridBagLayout对象  
②将容器设成此对象的布局管理器  
③创建约束(GridBagConstraints)对象  
④创建各个相应的组件  
⑤添加各个组件与约束到网格组布局管理器中

网格组由多个网格组成，而且各个行或者列的高度和宽度不同。但默认的情况下，单元格从左上角开始有序列地编号，从第0行第0列开始计数。当向网格组布局管理器中添加组件时，分别定义每个单元格的序列号，只要设定相应的值，那么组件就会添加到网格组布局管理器中。gridX、gridY分别定义了添加组件时左上角的行与列的位置，而gridwidth、gridheight分别定义了组件所占用的列数和行数。

网格组布局管理器中每个区域都要设置增量字段(weightx与weighty,分别代表x方向和y方向的增量)。如果想让某个区域保持初始化的大小，也就是说窗口缩放不会引起组件缩放，那就应该设置该区域的增量为0；相反如果让组件能完全保证填充单元格，那增量字段就应该设置为100。

fill和anchor参数都是非常重要的约束。  
其中fill是当组件不能填满单元格时，该参数就可以发挥作用。  
该约束的值主要有以下几种：  
GridBagConstraints.NONE:在每一个方向都不填充。即保持原状  
GridBagConstraints.HORIZONTAL:只在水平方向上填充  
GridBagConstraints.VERTICAL:只在垂直方向上填充  
GridBagConstraints.BOTH:在两个方向上都填充  
而anchor参数则是当一个组件大于分配给它的单元格时发挥作用，该约束  
就是约定如何处理该组件，它的值如下所示：  
GridBagConstraints.CENTER:居中缩小  
GridBagConstraints.NORTH:顶部缩小  
GridBagConstraints.NORTHEAST:左上角缩小  
GridBagConstraints.EAST:右侧缩小

## （3）流布局的设计 ##

流布局管理器将组件依次添加到容器中，组件在容器中按照从左到右、从上到下的顺序排列。  
例：

import java.awt.*;
    import javax.swing.*;
    import javax.swing.table.*;
    public class Swing extends JFrame{  
    	public Swing(){ 
    		//创建4个按钮对象
    		JButton b1=new JButton("Button 1");
    		JButton b2=new JButton("Button 2");
    		JButton b3=new JButton("Button 3");
    		JButton b4=new JButton("Button 4");
    		//创建流布局管理器，采用默认设置
    		FlowLayout f1=new FlowLayout();
    		Container cp=getContentPane();
    		cp.setLayout(f1);
    		//依次向容器添加组件
    		cp.add(b1);
    		cp.add(b2);
    		cp.add(b3);
    		cp.add(b4);
    	}
    	public static void main(String args[]){  //主方法
    		Swing tmt=new Swing();
    		tmt.setTitle("流布局管理器");
    		tmt.setSize(400,300);
    		tmt.show();
    	}
    }

如果第一排无法容纳组件，按照流布局管理器的排列规则，应该放在下一行，而且会放在第二行的中间位置（默认）。其实这个位置也是可以改变的，即组件在行内对齐的方式。并且可以设置组件与组件之间水平和垂直间隙的大小，单位为像素。如：  
FlowLayout f1=new FlowLayout(FlowLayout.LEFT,20,10);  
这说明组件间的水平距离为20个像素，垂直距离为10个像素。采用行内左对齐的方式对齐行内组件。  
例：

import java.awt.*;
    import javax.swing.*;
    import javax.swing.table.*;
    public class Swing extends JFrame{  
    	public Swing(){ 
    		//创建4个按钮对象
    		JButton b1=new JButton("Button 1");
    		JButton b2=new JButton("Button 2");
    		JButton b3=new JButton("Button 3");
    		JButton b4=new JButton("Button 4");
    		//创建流布局管理器，采用默认设置
    		FlowLayout f1=new FlowLayout(FlowLayout.LEFT,20,10);
    		Container cp=getContentPane();
    		cp.setLayout(f1);
    		//依次向容器添加组件
    		cp.add(b1);
    		cp.add(b2);
    		cp.add(b3);
    		cp.add(b4);
    	}
    	public static void main(String args[]){  //主方法
    		Swing tmt=new Swing();
    		tmt.setTitle("流布局管理器");
    		tmt.setSize(400,300);
    		tmt.show();
    	}
    }

## （4）边界布局的设计 ##

边界布局管理器将整个容器分为5个区域，分别为东、西、南、北和中间。组件可以放置在指定的一个区域。在BorderLayout类的定义中这5个区域用5个常量值表示：EAST、WEST、SOUTH、NORTH和CENTER。假设容器为cp，组件为jb。则将组件添加到容器上的方式为：  
BorderLayout bl=new BorderLayout();  
cp.add(jb,BorderLayout.CENTER);  
例：

import java.awt.*;
    import javax.swing.*;
    import javax.swing.table.*;
    public class Swing extends JFrame{  
    	public Swing(){ 
    		//创建按钮分别用于布局管理器管理的组件
    		JButton b1=new JButton("东");
    		JButton b2=new JButton("西");
    		JButton b3=new JButton("南");
    		JButton b4=new JButton("北");
    		JButton b5=new JButton("中");
    		//创建边界布局管理器
    		BorderLayout bl=new BorderLayout();
    		Container cp=getContentPane();
    		//设置容器的布局管理器为边界管理器
    		cp.setLayout(bl);
    		//依次向容器添加组件
    		cp.add(b1,BorderLayout.EAST);
    		cp.add(b2,BorderLayout.WEST);
    		cp.add(b3,BorderLayout.SOUTH);
    		cp.add(b4,BorderLayout.NORTH);
    		cp.add(b5,BorderLayout.CENTER);
    	}
    	public static void main(String args[]){  //主方法
    		Swing gmt=new Swing();
    		gmt.setTitle("边界布局管理器");
    		gmt.setSize(400,300);
    		gmt.show();
    	}
    }

容器中的5个区域不一定必须增加组件，如果某个区域如“东”侧空白，则中间区域的组件较先前会大些，如果中间空白不放置组件，则四个边沿组件大小不变，如果没有中间区域组件，也没有“北”侧区域组件，则“东”，“西”侧区域中的组件会延伸到容器“北”侧的边沿。

终极实例：

import java.awt.*;
    import javax.swing.*;
    import javax.swing.table.*;
    public class Swing {  
    	public static void main(String args[]){  //主方法
    		gridbaglayoutframe frame1=new gridbaglayoutframe();
    		//设置窗口关闭方法
    		frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		//显示窗口
    		frame1.show();
    	}
    }
    class gridbaglayoutframe extends JFrame{ 
    	private static final int WIDTH=300;
    	private static final int HEIGHT=200;
    	public gridbaglayoutframe(){ 
    		setTitle("学生管理系统");
    		setSize(WIDTH,HEIGHT);
    		Container con=getContentPane();
    		con.add(new studentJPanel(),BorderLayout.CENTER);
    		con.add(new buttonpanel(),BorderLayout.SOUTH);
    	}
    }
    //创建一个学生标签和文本域及文本区所在的容器类
    class studentJPanel extends JPanel{ 
    	public studentJPanel(){ 
    		//创建布局管理器对象
    		GridBagLayout layout=new GridBagLayout();
    		//设置窗口的布局管理器
    		setLayout(layout);
    		//创建关于姓名的标签和文本输入框
    		JLabel namelabel=new JLabel("姓名：");
    		JTextField nameTextField=new JTextField(10);
    		//创建关于学号的标签和文本输入框
    		JLabel codelabel=new JLabel("学号：");
    		JTextField codeTextField=new JTextField(10);
    		//创建关于性别的标签和文本输入框
    		JLabel sexlabel=new JLabel("性别：");
    		JTextField sexTextField=new JTextField(10);
    		//创建关于籍贯的标签和文本输入框
    		JLabel addresslabel=new JLabel("籍贯：");
    		JComboBox addressCombo=new JComboBox(new String[]
    				{ "江西","四川","辽宁","湖南"});
    		//创建关于简单介绍的标签和文本输入域
    		JLabel commentLabel=new JLabel("简单介绍");
    		JTextArea sample=new JTextArea();
    		sample.setLineWrap(true);
    		//创建和设置对象
    		GridBagConstraints constraints=new GridBagConstraints();
    		constraints.fill=GridBagConstraints.NONE;
    		constraints.anchor=GridBagConstraints.EAST;
    		constraints.weightx=5;
    		constraints.weighty=5;
    		//添加对象到constraints对象
    		add(namelabel,constraints,0,0,1,1);
    		add(codelabel,constraints,0,1,1,1);
    		add(sexlabel,constraints,0,2,1,1);
    		add(addresslabel,constraints,0,3,1,1);
    		//创建和设置对象
    		constraints.fill=GridBagConstraints.HORIZONTAL;
    		constraints.weightx=100;
    		add(nameTextField,constraints,1,0,1,1);
    		add(codeTextField,constraints,1,1,1,1);
    		add(sexTextField,constraints,1,2,1,1);
    		add(addressCombo,constraints,1,3,1,1);
    		//创建和设置对象
    		constraints.fill=GridBagConstraints.NONE;
    		constraints.anchor=GridBagConstraints.CENTER;
    		add(sample,constraints,2,0,1,1);
    		constraints.fill=GridBagConstraints.BOTH;
    		add(sample,constraints,2,1,1,1);
    	}
    	//用来添加组件到容器中的函数
    	public void add(Component c,GridBagConstraints constraints,
    			int x,int y,int w,int h){ 
    		constraints.gridx=x; //关于控件位于哪一列
    		constraints.gridy=y; //关于控件位于哪一行
    		constraints.gridwidth=w; //关于控件占据多少列
    		constraints.gridheight=h;//关于控件占据多少行
    		add(c,constraints);
    	}
    }
    //设置放置按钮控件的容器类
    class buttonpanel extends JPanel{ 
    	public buttonpanel(){ 
    		setLayout(new BoxLayout(this,BoxLayout.X_AXIS));
    		//创建确定和取消按钮
    		JButton okbutton=new JButton("确定");
    		JButton cancelbutton=new JButton("取消");
    		//创建和设置对象
    		Box hBox=Box.createHorizontalBox();
    		hBox.add(Box.createHorizontalStrut(40));
    		hBox.add(okbutton);
    		hBox.add(Box.createHorizontalGlue());
    		hBox.add(cancelbutton);
    		hBox.add(Box.createHorizontalStrut(40));
    		add(hBox);
    	}
    }

注：如何编写快捷键的程序？  
按照下面的代码方式定义：  
JMenu save=new JMenu(“save”);  
Save.setMnemonic(‘s’);  
这里将save菜单项的快捷键定义为"s"