疯狂JAVA讲义---第十一章（上）：AWT编程-布局管理器

从今天开始的这几天，我主要讲java的GUI编程。

图形用户界面（Graphics user interface, GUI）是指用图形的方式，借助菜单、按钮等标准界面元素和鼠标操作，帮助用户方便地向计算机系统发出指令、启动操作，并将系统运行的结果以图形方式显示给用户的技术。
由于用户界面设计质量的好坏直接影响软件的使用，Java语言对此也十分重视，几乎在JDK每个新的版本中，都增加了一定的GUI程序设计新技术或功能，Java语言的GUI发展始终保持着较好的连贯性和兼容性。

目前Java主要提供了两个处理图形用户界面的类库：java.awt和javax.swing。
AWT：抽象窗口工具集（Abstract Windows Toolkit）,由于Java代码可以在不同的系统平台运行，而不同平台的图形界面外观设计各有差异，所以Java程序的图形用户界面在不同的平台上可能出现不同的运行效果，其外观取决于具体的平台，所以称AWT是一个抽象的工具集。
Swing：Swing是在AWT的基础上构建的，提供了比标准AWT组件更强大和灵活的功能。与AWT组件不同的是，Swing组件不是由特定的平台代码实现，而是纯粹的Java代码，因此能够实现与平台的无关（此类组件一般被称为轻量级组件）。

 

利用GUI类库设计和实现图形用户界面的工作主要有两个：一是应用的外观设计，即创建组成图形界面的各部件，指定其位置和属性关系，根据需要进行排列，从而构成完整的图形用户界面的物理外观；二是与用户的交互处理，包括定义图形用户界面的事件以及各部件对不同时间的响应处理。

那现在开始就先讲AWT。AWT类包含在java.awt包中，主要包括用户界面组件、事件处理模型、图形和图像工具、布局管理器等。Java.awt包中的主要类及组件类的继承关系如图

先来个最简单的例子，eg

1. • public class TestPanel
   • {
   •     public static void main(String[] args) 
   •     {
   •         Frame f = new Frame("测试窗口");
   •         //创建一个Panel对象
   •         Panel p = new Panel();
   •         //相Panel对象中添加两个组件
   •         p.add(new TextField(20));
   •         p.add(new Button("单击我"));
   •         f.add(p);
   •         //设置窗口的大小、位置
   •         f.setBounds(30, 30 , 250, 120);
   •         //将窗口显示出来（Frame对象默认处于隐藏状态）
   •         f.setVisible(true);
   •     }
   • }

然后我讲下布局管理器AWT中分为

FlowLayout

BorderLayout
CardLayout
GridLayout
GridBagLayout

这五种

Swing的话再加上BoxLayout

顺序布局（FlowLayout）是Panel容器的缺省布局策略，即将加入容器中的组件依次从左至右，从上至下排列，适用于组件个数较少的情况。eg

1. public class TestFlowLayout
2. {
3.     public static void main(String[] args) 
4.     {
5.         Frame f = new Frame("测试窗口");
6.         //设置Frame容器使用FlowLayout布局管理器
7.         f.setLayout(new FlowLayout(FlowLayout.LEFT , 20, 5));
8.         //向窗口中添加10个按钮
9.         for (int i = 0; i < 10 ; i++ )
10.         {
11.             f.add(new Button("按钮" + i));
12.         }
13.         //设置窗口为最佳大小
14.         f.pack();
15.         //将窗口显示出来（Frame对象默认处于隐藏状态）
16.         f.setVisible(true);
17.     }
18. }

pack()方法非常有用，能讲窗口调整到最佳大小

边界布局（BorderLayout）是Frame，Dialog，ScrollPane的缺省布局。区域布局将容器分为东西南北中五个区域，加入组件时，应通过字符串East/West /South/North/Center来标记组件的方位。eg

1. public class TestBorderLayout
2. {
3.     public static void main(String[] args) 
4.     {
5.         Frame f = new Frame("测试窗口");
6.         //设置Frame容器使用BorderLayout布局管理器
7.         f.setLayout(new BorderLayout(30, 5));
8.         f.add(new Button("南") , BorderLayout.SOUTH);
9.         f.add(new Button("北") , BorderLayout.NORTH);
10.         //默认添加到中间
11.         f.add(new Button("中"));
12.         f.add(new Button("东") , BorderLayout.EAST);
13.         f.add(new Button("西") , BorderLayout.WEST);
14.         //设置窗口为最佳大小
15.         f.pack();
16.         //将窗口显示出来（Frame对象默认处于隐藏状态）
17.         f.setVisible(true);
18.     }
19. }

卡片布局（CardLayout）将容器中的每一个组件当作一个卡片，一次仅有一个卡片可见，最初显示容器时，加入到容器的第一个组件可见。eg

 

1. public class TestCardLayout
2. {
3.     Frame f = new Frame("测试窗口");
4.     String[] names = {"第一张" , "第二张" , "第三张" , "第四张" , "第五张"};
5.     Panel pl = new Panel();
6.     CardLayout c = new CardLayout();
7.     public void init()
8.     {
9.         pl.setLayout(c);
10.         for (int i = 0 ; i < names.length ; i++)
11.         {
12.             pl.add(names[i] , new Button(names[i]));
13.         }
14.         Panel p = new Panel();
15.         //控制显示上一张的按钮
16.         Button previous = new Button("上一张");
17.         previous.addActionListener(new ActionListener()
18.         {
19.             public void actionPerformed(ActionEvent e)
20.             {
21.                 c.previous(pl);
22.             }
23.         });
24.         //控制显示下一张的按钮
25.         Button next = new Button("下一张");
26.         next.addActionListener(new ActionListener()
27.         {
28.             public void actionPerformed(ActionEvent e)
29.             {
30.                 c.next(pl);
31.             }
32.         });
33.         //控制显示第一张的按钮
34.         Button first = new Button("第一张");
35.         first.addActionListener(new ActionListener()
36.         {
37.             public void actionPerformed(ActionEvent e)
38.             {
39.                 c.first(pl);
40.             }
41.         });
42.         //控制显示最后一张的按钮
43.         Button last = new Button("最后一张");
44.         last.addActionListener(new ActionListener()
45.         {
46.             public void actionPerformed(ActionEvent e)
47.             {
48.                 c.last(pl);
49.             }
50.         });
51.         //控制根据Card名显示的按钮
52.         Button third = new Button("第三张");
53.         third.addActionListener(new ActionListener()
54.         {
55.             public void actionPerformed(ActionEvent e)
56.             {
57.                 c.show(pl , "第三张");
58.             }
59.         });
60.         p.add(previous);
61.         p.add(next);
62.         p.add(first);
63.         p.add(last);
64.         p.add(third);
65.         f.add(pl);
66.         f.add(p , BorderLayout.SOUTH);
67.         f.pack();
68.         f.setVisible(true);
69.     }
70.     public static void main(String[] args) 
71.     {
72.         new TestCardLayout().init();
73.     }
74. }

网格布局(GridLayout)

 

将容器划分为n*m的大小相同的小格，每格区间可摆放一个组件。向容器中增加组件时，按从左至右，从上至下的顺序依次存放.eg

1. public class TestGridLayout
2. {
3.     public static void main(String[] args) 
4.     {
5.         Frame f = new Frame("计算器");
6.         Panel p1 = new Panel();
7.         p1.add(new TextField(30));
8.         f.add(p1 , BorderLayout.NORTH);
9.         Panel p2 = new Panel();
10.         //设置Panel使用GridLayout布局管理器
11.         p2.setLayout(new GridLayout(3, 5 , 4, 4));
12.         String[] name = {"0" , "1" , "2" , "3" , "4" , "5" , 
13.             "6" , "7" , "8" , "9" , "+" , "-" , "*" , "/" , "."};
14.         //向Panel中依次添加15个按钮
15.         for (int i = 0 ; i < name.length; i++ )
16.         {
17.             p2.add(new Button(name[i]));
18.         }
19.         f.add(p2);
20.         //设置窗口为最佳大小
21.         f.pack();
22.         //将窗口显示出来（Frame对象默认处于隐藏状态）
23.         f.setVisible(true);
24.     }
25. }

网格包布局（GridBagLayout）这个功能最强大，但用起来太麻烦了。将视图分为多个单元，可以指定每个组件占用的单元
GridBagConstraints类-参数：
gridx,gridy:组件的位置
gridwidth,gridheight:组件覆盖的网格单元个数
insets:组件和包含它的网格单元之间的距离
weightx,weighty:视图大小变化时，组件的情况，标准为100，0为组件占用空间不变
fill:填充方式，4种
anchor:组件在网格单元中的位置，CENTER/NORTH/NORTHWEST。eg

1. public class TestGridBag
2. {
3.     private Frame f = new Frame("测试窗口");
4.     private GridBagLayout gb = new GridBagLayout();
5.     private GridBagConstraints gbc = new GridBagConstraints();
6.     private Button[] bs = new Button[10];
7.     public void init()
8.     {
9.         f.setLayout(gb);
10.         for (int i = 0; i < bs.length ; i++ )
11.         {
12.             bs[i] = new Button("按钮" + i);
13.         }
14.         //所有组件都可以横向、纵向上扩大
15.         gbc.fill = GridBagConstraints.BOTH;
16.         gbc.weightx = 1;
17.         addButton(bs[0]);
18.         addButton(bs[1]);
19.         addButton(bs[2]);
20.         //该GridBagConstraints控制的GUI组件将会成为横向最后一个元素
21.         gbc.gridwidth = GridBagConstraints.REMAINDER;
22.         addButton(bs[3]);
23.         //该GridBagConstraints控制的GUI组件将横向上不会扩大
24.         gbc.weightx = 0;
25.         addButton(bs[4]);
26.         //该GridBagConstraints控制的GUI组件将横跨2个网格
27.         gbc.gridwidth = 2;
28.         addButton(bs[5]);
29.         //该GridBagConstraints控制的GUI组件将横跨1个网格
30.         gbc.gridwidth = 1;
31.         //该GridBagConstraints控制的GUI组件将纵向跨2个网格
32.         gbc.gridheight = 2;
33.         //该GridBagConstraints控制的GUI组件将会成为横向最后一个元素
34.         gbc.gridwidth = GridBagConstraints.REMAINDER;
35.         addButton(bs[6]);
36.         //该GridBagConstraints控制的GUI组件将横向跨越一个网格，纵向跨越2个网格。
37.         gbc.gridwidth = 1;
38.         gbc.gridheight = 2;
39.         //该GridBagConstraints控制的GUI组件纵向扩大的权重是1
40.         gbc.weighty = 1;
41.         addButton(bs[7]);
42.         //设置下面的按钮在纵向上不会扩大
43.         gbc.weighty = 0;
44.         //该GridBagConstraints控制的GUI组件将会成为横向最后一个元素
45.         gbc.gridwidth = GridBagConstraints.REMAINDER;
46.         //该GridBagConstraints控制的GUI组件将纵向上横跨1个网格
47.         gbc.gridheight = 1;
48.         addButton(bs[8]);
49.         addButton(bs[9]);
50.         f.pack();
51.         f.setVisible(true);
52.     }
53.     private void addButton(Button button) 
54.     {
55.         gb.setConstraints(button, gbc);
56.         f.add(button);
57.     }
58.     public static void main(String[] args) 
59.     {
60.         new TestGridBag().init();
61.     }
62. }

盒子布局（BoxLayout）对GridBagLayout进行了简化，保留了它的优点。Box容器的默认布局管理就是它。它是通过横向或纵向放置器件。eg

1. public class TestBoxSpace
2. {
3.     private Frame f = new Frame("测试");
4.     //定义水平摆放组件的Box对象
5.     private Box horizontal = Box.createHorizontalBox();
6.     //定义垂直摆放组件的Box对象
7.     private Box vertical = Box.createVerticalBox();
8.     public void init()
9.     {
10.         horizontal.add(new Button("水平按钮一"));
11.         horizontal.add(Box.createHorizontalGlue());
12.         horizontal.add(new Button("水平按钮二"));
13.         //水平方向不可拉伸的间距，其宽度为10px
14.         horizontal.add(Box.createHorizontalStrut(10));
15.         horizontal.add(new Button("水平按钮三"));
16.         vertical.add(new Button("垂直按钮一"));
17.         vertical.add(Box.createVerticalGlue());
18.         vertical.add(new Button("垂直按钮二"));
19.         //垂直方向不可拉伸的间距，其高度为10px
20.         vertical.add(Box.createVerticalStrut(10));
21.         vertical.add(new Button("垂直按钮三"));
22.         f.add(horizontal , BorderLayout.NORTH);
23.         f.add(vertical);
24.         f.pack();
25.         f.setVisible(true);
26.     }
27.     public static void main(String[] args) 
28.     {
29.         new TestBoxSpace().init();
30.     }
31. }