您的位置: 首页  >  文章  >  Java之GUI编程（二）——布局管理器（转载自己保存学习用）

Java之GUI编程（二）——布局管理器（转载自己保存学习用）

分类: 文章 • 2023-12-01 15:13:52

  在上篇博客Java之GUI编程（一）中我已经对GUI编程的组件和事件做了简单介绍了，现在来看看另外一部分关于组件在各个平台是如何做到仍能保持自己合理的位置大小以及外观的。

        已经说了Java是跨平台运行的，但是不同的平台对于点及坐标的定义不完全相同。而且屏幕的解析度分辨率不同也会造成位置的变化，为了确保每个组件的相对位置和大小以及外观，java就设计了布局管理器。

       布局管理器是对容器中的元素进行管理，按照一定的规则排放容器里面的元素。它控制了组件的摆放。

布局管理器分类：

        FlowLayout：浮动布局管理器

        BorderLayout：边框布局管理器

        GridLayout：网格布局管理器

       CardLayout：卡片布局管理器

       GridBagLayout：网格包布局管理器


FlowLayout

       是Panel容器的默认管理器，其组件浮动在容器中，它的放置规律是从上到下，从左到右。
实例：
[java] view plain copy
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3. public class FrameTest{  
  4.     public static void main(String[] args)  
  5.     {  
  6.     //创建一个框架  
  7.         Frame f=new Frame("Test");  
  8.         //设置窗体大小  
  9.         f.setSize(800,600);  
  10.         //设置窗体显示位置  
  11.         f.setLocation(100,100);  
  12.         Button btn1=new Button("Button1"); //创建按钮对象  
  13.         f.setBackground(Color.BLUE); //窗体背景色  
  14.         f.setVisible(true);    //窗体可见  
  15.       f.setLayout(new FlowLayout());//设置浮动布局方式  
  16.         Button btn2=new Button("Button2");  
  17.         Button btn3=new Button("Button3");  
  18.         Button btn4=new Button("Button4");  
  19.         Button btn5=new Button("Button5");  
  20.         f.add(btn1);   
  21.         f.add(btn2);  
  22.         f.add(btn3);  
  23.         f.add(btn4);  
  24.         f.add(btn5);  
  25.     }  
  26. }  
运行结果：
         Java之GUI编程（二）——布局管理器（转载自己保存学习用）    图一
         Java之GUI编程（二）——布局管理器（转载自己保存学习用）    图二
分析：
       当我改变窗口的大小，相应的组件的位置也会发生改变，由图一的显示方式变成图二的显示方式。对于FlowLayout还提供了按钮的对齐方式，比如说f.setLayout(new FlowLayout(FlowLayout.LEFT))，就设置了左对齐的方式，这些按钮将会从左边依次摆放。

BorderLayout

       布置容器的边框布局，可以对容器组件进行安排，并调整其大小，使其符合五个区域：北、南、东、西、中。每个区域最多只能包含一个组件，并通过相应的常量进行标识：NORTH、SOUTH、EAST、WEST、CENTER，若只有一个组件，默认位置为Center，是Window、Frame和Dialog的默认布局管理器。 
 实例：    
[java] view plain copy
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3. public class FrameTest{  
  4.     public static void main(String[] args)  
  5.     {  
  6.     //创建一个框架  
  7.         Frame f=new Frame("Test");  
  8.         //设置窗体大小  
  9.         f.setSize(800,600);  
  10.         //设置窗体显示位置  
  11.         f.setLocation(100,100);  
  12.         Button btn1=new Button("Button1"); //创建按钮对象  
  13.         f.setBackground(Color.BLUE); //窗体背景色  
  14.         f.setVisible(true);    //窗体可见  
  15.         Button btn2=new Button("Button2");  
  16.         Button btn3=new Button("Button3");  
  17.         Button btn4=new Button("Button4");  
  18.         Button btn5=new Button("Button5");  
  19.         f.add(btn1,"Center"); //将按钮添加到窗体中，并设置显示位置  
  20.         f.add(btn2,"North");  
  21.         f.add(btn3,"West");  
  22.         f.add(btn4,"South");  
  23.         f.add(btn5,"East");  
  24.     }  
  25. }  
运行结果：
          Java之GUI编程（二）——布局管理器（转载自己保存学习用）
分析：
       在上面的程序中，可以看到在创建Frame后必须设置位置参数，才能成功显示出来，其实Frame的设置并不只有这些，详看可以查阅Java帮助文档。

GridLayout

      将容器分成网格，在创建GridLayout布局管理器对象的时候需要传递两个参数，一个代表行另一个代表列。
实例： 
[java] view plain copy
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3. public class FrameTest{  
  4.     public static void main(String[] args)  
  5.     {  
  6.     //创建一个框架  
  7.         Frame f=new Frame("Test");  
  8.         //设置窗体大小  
  9.         f.setSize(800,600);  
  10.         //设置窗体显示位置  
  11.         f.setLocation(100,100);  
  12.         Button btn1=new Button("Button1"); //创建按钮对象  
  13.         f.setBackground(Color.BLUE); //窗体背景色  
  14.         f.setVisible(true);    //窗体可见  
  15.       //f.setLayout(new FlowLayout());//设置浮动布局方式  
  16.       f.setLayout(new GridLayout(3,1,10,10));//设置布局方式并设置组件间间隙  
  17.         Button btn2=new Button("Button2");  
  18.         Button btn3=new Button("Button3");  
  19.         Button btn4=new Button("Button4");  
  20.         Button btn5=new Button("Button5");  
  21.         f.add(btn1);   
  22.         f.add(btn2);  
  23.         f.add(btn3);  
  24.         f.add(btn4);  
  25.         f.add(btn5);  
  26.     }  
  27. }  
运行结果：
          Java之GUI编程（二）——布局管理器（转载自己保存学习用）
分析：
       布局后的版面就如同表格一样整齐有序，加入的组件按顺序由左至右、由上至下摆放，所以无法直接指定要摆放的区域，同时，组件放入后变成了方形。

CardLayout

       容器中虽然有多个组件，但是我们只会看到最上面的组件，组件在重叠起来的就像重叠起来的扑克牌，每次只能看到最上面的那张。
实例：    
[java] view plain copy
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3. import javax.swing.*;  
  4. public class FrameTest {  
  5.     private static JPanel p;  
  6.     public static void main(String[] args) {  
  7.         JFrame f=new JFrame("CardLayout");  
  8.         p=new JPanel();  
  9.         //将JPanel p的LayoutManager设置为CardLayout  
  10.         p.setLayout(new CardLayout());  
  11.   
  12.         //新建两个JPanel  
  13.         JPanel p1=new JPanel();  
  14.         JPanel p2=new JPanel();  
  15.         JLabel lb=new JLabel("first panel");  
  16.         p1.add(lb);  
  17.         lb=new JLabel("second panel");  
  18.         p2.add(lb);  
  19.   
  20.         //将新建的两个JPanel p1,p2添加到p中  
  21.         p.add(p1,"frist");  
  22.         p.add(p2,"second");  
  23.   
  24.         //设置默认显示first所对应的JPanel p1  
  25.         ((CardLayout)p.getLayout()).show(p, "frist");  
  26.   
  27.         JButton cbtn=new JButton("Change");  
  28.         cbtn.addActionListener(new ActionListener(){  
  29.             public void actionPerformed(ActionEvent e) {  
  30.                 //当按下Change按钮时，显示second 对应的JPanel p2  
  31.                 ((CardLayout)p.getLayout()).show(p, "second");  
  32.             }  
  33.         });  
  34.           
  35.         f.add(cbtn,BorderLayout.NORTH);  
  36.         f.add(p,BorderLayout.CENTER);  
  37.         f.setSize(400,150);  
  38.         f.setVisible(true);  
  39.         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  40.     }  
  41. }   
运行结果：
        Java之GUI编程（二）——布局管理器（转载自己保存学习用）
分析：
       在按下按钮（Change）后，出现上面运行结果，看似只有一个组件，其实可能蕴藏了很多个组件。

GridBagLayout

       是所有AWT布局管理器当中最复杂的，功能也是最强大的。这是因为它所提供了很多的可配置选项，几乎可以完全地控制容器的布局方式。尽管复杂，理解了基本思想，还是很容易。
实例：
[java] view plain copy
  1. import java.awt.GridBagLayout;    
  2. import java.awt.GridBagConstraints;    
  3. import java.awt.Insets;    
  4. import javax.swing.JFrame;    
  5. import javax.swing.JButton;    
  6.      
  7. public class FrameTest {    
  8.     
  9.     public static void main(String[] args) {    
  10.         JFrame f=new JFrame("GridBagLayout");    
  11.         f.setLayout(new GridBagLayout());    
  12.         JButton btn=new JButton("Button1");    
  13.         GridBagConstraints gbc=new GridBagConstraints();    
  14.         //设定第一个单元格的属性值    
  15.         gbc.gridx=0;  //横坐标  
  16.         gbc.gridy=0;  //纵坐标  
  17.         gbc.gridwidth=1;  //组件宽  
  18.         gbc.gridheight=1;  //组件高  
  19.         gbc.weightx=0;  //行的权重，通过这个属性来决定如何分配行的剩余空间  
  20.         gbc.weighty=0;    
  21.         gbc.anchor=GridBagConstraints.NORTHWEST;   
  22.          //当组件在格内而不能撑满其格时，通过fill的值来设定填充方式，有四个值  
  23.         gbc.fill=GridBagConstraints.NONE;    
  24.         gbc.insets=new Insets(0,0,0,0);    
  25.         gbc.ipadx=0;  //组件间的横向间距  
  26.         gbc.ipady=0;  //组件间的纵向间距  
  27.         f.add(btn,gbc);    
  28.     
  29.         //设定第二个单元格属性值    
  30.         gbc.gridx=1;    
  31.         gbc.gridy=0;    
  32.         gbc.gridwidth=GridBagConstraints.REMAINDER;    
  33.         gbc.gridheight=1;    
  34.         gbc.weightx=1;    
  35.         gbc.weighty=0;    
  36.          // 当组件小于其显示区域时，用于确定将组件置于何处（在显示区域中）  
  37.         gbc.anchor=GridBagConstraints.CENTER;    
  38.         gbc.fill=GridBagConstraints.HORIZONTAL;    
  39.         gbc.insets=new Insets(5,5,5,5);  //设置组件之间彼此的间距  
  40.         gbc.ipadx=0;    
  41.         gbc.ipady=0;    
  42.         btn=new JButton("Button2");    
  43.         f.add(btn,gbc);    
  44.     
  45.         //设定第三个单元格属性值    
  46.         gbc.gridx=0;    
  47.         gbc.gridy=1;    
  48.         gbc.gridwidth=1;    
  49.         gbc.gridheight=GridBagConstraints.REMAINDER;    
  50.         gbc.weightx=0;    
  51.         gbc.weighty=1;   
  52.         gbc.anchor=GridBagConstraints.CENTER;    
  53.         gbc.fill=GridBagConstraints.VERTICAL;    
  54.         gbc.insets=new Insets(0,0,0,0);    
  55.         gbc.ipadx=10;    
  56.         gbc.ipady=10;    
  57.         btn=new JButton("Button3");    
  58.         f.add(btn,gbc);    
  59.         f.pack();    
  60.         f.setVisible(true);    
  61.         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    
  62.     }    
  63.     
  64. }    
运行结果：
          Java之GUI编程（二）——布局管理器（转载自己保存学习用）
分析：
       它同GridLayout一样,在容器中以网格形式来管理组件，只是功能比GridLayout强大。GridBagLayout管理的所有行和列可以大小不同。 GridLayout把每个组件限制到一个单元格，而GridBagLayout并不这样，其组件在容器中可以占据任意大小的矩形位置。

总结

        GUI编程注重界面美观，满足用户的视觉享受，J2se中现有的布局管理器，让java界面更好的跨平台使用。而我仅仅是将一些我当前学到的这几种布局管理器进行了总结，其实，所有的布局管理器都要实现一个接口，即LayoutManager Inerface或者是它的一个子接口LayoutManager2 Interface（适用于更复杂的布局管理），由此，是不是也可以通过实现这个接口，编写适合自己需要的布局管理器。。。。

相关推荐